1 Introduction
This document contains the informal mathematical content derived from the Lean 4 formalization in the QEC1 library.
[Notation Conventions]
Throughout this work, we use the following notation and conventions:
Pauli operators: For a qubit system on \(n\) qubits, the Pauli group is generated by single-qubit operators \(X_i\), \(Y_i\), \(Z_i\) for \(i \in \{ 1, \ldots , n\} \) satisfying \(X_i^2 = Y_i^2 = Z_i^2 = I\), \(X_i Y_i = i Z_i\), and operators on different qubits commute.
Stabilizer code: An \([[n, k, d]]\) stabilizer code is a \(2^k\)-dimensional subspace of the \(n\)-qubit Hilbert space \((\mathbb {C}^2)^{\otimes n}\) defined as the simultaneous \(+1\) eigenspace of an abelian subgroup \(S\) of the \(n\)-qubit Pauli group, where \(-I \notin S\).
Code distance: The distance \(d\) is the minimum weight of a Pauli operator that commutes with all stabilizers but is not itself a stabilizer.
Support notation: For a Pauli operator \(P = i^{\sigma } \prod _v X_v^{a_v} Z_v^{b_v}\), the \(X\)-type support is \(S_X(P) = \{ v : a_v = 1\} \) and the \(Z\)-type support is \(S_Z(P) = \{ v : b_v = 1\} \).
\(\mathbb {Z}_2\)-arithmetic: All sums of binary vectors are computed modulo 2. We identify a subset \(S \subseteq V\) with the binary vector \((\mathbf{1}_S)_v = [v \in S] \in \mathbb {Z}_2^{|V|}\).
No proof needed for remarks.
The four single-qubit Pauli operators form an inductive type:
\(I\): Identity
\(X\): Pauli-X (bit flip)
\(Y\): Pauli-Y
\(Z\): Pauli-Z (phase flip)
The number of Pauli operators is 4, i.e., \(|\texttt{PauliOp}| = 4\).
This holds by reflexivity (definitional equality).
Multiplication of single-qubit Pauli operators (ignoring phase) is defined by:
\(I \cdot P = P\) and \(P \cdot I = P\) for all \(P\)
\(X \cdot X = Y \cdot Y = Z \cdot Z = I\)
\(X \cdot Y = Z\), \(Y \cdot X = Z\)
\(Y \cdot Z = X\), \(Z \cdot Y = X\)
\(Z \cdot X = Y\), \(X \cdot Z = Y\)
For all Pauli operators \(P\), we have \(I \cdot P = P\).
We consider cases on \(P\). In each case (\(P = I\), \(P = X\), \(P = Y\), \(P = Z\)), the result holds by reflexivity.
For all Pauli operators \(P\), we have \(P \cdot I = P\).
We consider cases on \(P\). In each case (\(P = I\), \(P = X\), \(P = Y\), \(P = Z\)), the result holds by reflexivity.
For all Pauli operators \(P\), we have \(P^2 = I\).
We consider cases on \(P\). In each case (\(P = I\), \(P = X\), \(P = Y\), \(P = Z\)), we have \(P \cdot P = I\) by reflexivity (from the definition of multiplication).
A Pauli operator has an \(X\) component if it is \(X\) or \(Y\) (since \(Y = iXZ\)):
\(\texttt{hasX}(I) = \texttt{false}\)
\(\texttt{hasX}(X) = \texttt{true}\)
\(\texttt{hasX}(Y) = \texttt{true}\)
\(\texttt{hasX}(Z) = \texttt{false}\)
A Pauli operator has a \(Z\) component if it is \(Z\) or \(Y\) (since \(Y = iXZ\)):
\(\texttt{hasZ}(I) = \texttt{false}\)
\(\texttt{hasZ}(X) = \texttt{false}\)
\(\texttt{hasZ}(Y) = \texttt{true}\)
\(\texttt{hasZ}(Z) = \texttt{true}\)
The Pauli-\(Y\) operator has both \(X\) and \(Z\) components: \(\texttt{hasX}(Y) = \texttt{true}\) and \(\texttt{hasZ}(Y) = \texttt{true}\).
Both equalities hold by reflexivity from the definitions.
The identity operator has neither \(X\) nor \(Z\) component: \(\texttt{hasX}(I) = \texttt{false}\) and \(\texttt{hasZ}(I) = \texttt{false}\).
Both equalities hold by reflexivity from the definitions.
An \(n\)-qubit Pauli string is a function from qubit indices to single-qubit Paulis. This represents \(P = \prod _v P_v\) where \(P_v \in \{ I, X, Y, Z\} \). We use \(\texttt{Fin}\ n\) for qubit indices (0-indexed, representing qubits 1 to \(n\)).
The identity Pauli string of length \(n\) is the function that maps every qubit index to the identity operator \(I\).
A single-site \(X\) operator at position \(i\) is the Pauli string that is \(X\) at position \(i\) and \(I\) everywhere else.
A single-site \(Y\) operator at position \(i\) is the Pauli string that is \(Y\) at position \(i\) and \(I\) everywhere else.
A single-site \(Z\) operator at position \(i\) is the Pauli string that is \(Z\) at position \(i\) and \(I\) everywhere else.
Pointwise multiplication of Pauli strings (ignoring global phase): for Pauli strings \(P\) and \(Q\), their product is defined by \((P \cdot Q)(i) = P(i) \cdot Q(i)\) for each qubit index \(i\).
For all Pauli strings \(P\), we have \(\texttt{identity} \cdot P = P\).
By extensionality, it suffices to show equality for arbitrary index \(i\). By simplification using the definitions of multiplication, identity, and the fact that \(I \cdot P(i) = P(i)\), the result follows.
For all Pauli strings \(P\), we have \(P \cdot \texttt{identity} = P\).
By extensionality, it suffices to show equality for arbitrary index \(i\). By simplification using the definitions of multiplication, identity, and the fact that \(P(i) \cdot I = P(i)\), the result follows.
For all Pauli strings \(P\), we have \(P^2 = \texttt{identity}\).
By extensionality, it suffices to show equality for arbitrary index \(i\). By simplification using the definitions of multiplication, identity, and the fact that \(P(i)^2 = I\), the result follows.
The \(X\)-type support of a Pauli string \(P\) is the set of qubits where \(P\) has an \(X\) or \(Y\) component:
The \(Z\)-type support of a Pauli string \(P\) is the set of qubits where \(P\) has a \(Z\) or \(Y\) component:
The weight of a Pauli string \(P\) is the number of non-identity sites:
The identity Pauli string has empty \(X\)-support: \(S_X(\texttt{identity}) = \emptyset \).
By simplification using the definitions of \(S_X\), identity, and \(\texttt{hasX}\), the filter condition is never satisfied. For any index \(i\) in the universe, \(\texttt{hasX}(I) = \texttt{false}\), which is verified by computation.
The identity Pauli string has empty \(Z\)-support: \(S_Z(\texttt{identity}) = \emptyset \).
By simplification using the definitions of \(S_Z\), identity, and \(\texttt{hasZ}\), the filter condition is never satisfied. For any index \(i\) in the universe, \(\texttt{hasZ}(I) = \texttt{false}\), which is verified by computation.
The identity Pauli string has weight 0: \(\texttt{weight}(\texttt{identity}) = 0\).
By simplification using the definitions, the condition \(P(i) \neq I\) is never satisfied for the identity string (since \(I \neq I\) is false), so the filter is empty and has cardinality 0.
A single \(X\) operator at position \(i\) has \(X\)-support \(\{ i\} \): \(S_X(\texttt{singleX}(i)) = \{ i\} \).
By extensionality, we show \(j \in S_X(\texttt{singleX}(i)) \Leftrightarrow j = i\). For the forward direction, assume \(j \in S_X(\texttt{singleX}(i))\). We consider whether \(j = i\). If \(j = i\), we are done. If \(j \neq i\), then \(\texttt{singleX}(i)(j) = I\), so \(\texttt{hasX}(I) = \texttt{false}\), contradicting the assumption. For the reverse direction, if \(j = i\), then \(\texttt{singleX}(i)(i) = X\) and \(\texttt{hasX}(X) = \texttt{true}\).
A single \(Z\) operator at position \(i\) has \(Z\)-support \(\{ i\} \): \(S_Z(\texttt{singleZ}(i)) = \{ i\} \).
By extensionality, we show \(j \in S_Z(\texttt{singleZ}(i)) \Leftrightarrow j = i\). For the forward direction, assume \(j \in S_Z(\texttt{singleZ}(i))\). We consider whether \(j = i\). If \(j = i\), we are done. If \(j \neq i\), then \(\texttt{singleZ}(i)(j) = I\), so \(\texttt{hasZ}(I) = \texttt{false}\), contradicting the assumption. For the reverse direction, if \(j = i\), then \(\texttt{singleZ}(i)(i) = Z\) and \(\texttt{hasZ}(Z) = \texttt{true}\).
A single \(Y\) operator at position \(i\) has \(X\)-support \(\{ i\} \): \(S_X(\texttt{singleY}(i)) = \{ i\} \).
By extensionality, we show \(j \in S_X(\texttt{singleY}(i)) \Leftrightarrow j = i\). For the forward direction, assume \(j \in S_X(\texttt{singleY}(i))\). We consider whether \(j = i\). If \(j = i\), we are done. If \(j \neq i\), then \(\texttt{singleY}(i)(j) = I\), so \(\texttt{hasX}(I) = \texttt{false}\), contradicting the assumption. For the reverse direction, if \(j = i\), then \(\texttt{singleY}(i)(i) = Y\) and \(\texttt{hasX}(Y) = \texttt{true}\).
A single \(Y\) operator at position \(i\) has \(Z\)-support \(\{ i\} \): \(S_Z(\texttt{singleY}(i)) = \{ i\} \).
By extensionality, we show \(j \in S_Z(\texttt{singleY}(i)) \Leftrightarrow j = i\). For the forward direction, assume \(j \in S_Z(\texttt{singleY}(i))\). We consider whether \(j = i\). If \(j = i\), we are done. If \(j \neq i\), then \(\texttt{singleY}(i)(j) = I\), so \(\texttt{hasZ}(I) = \texttt{false}\), contradicting the assumption. For the reverse direction, if \(j = i\), then \(\texttt{singleY}(i)(i) = Y\) and \(\texttt{hasZ}(Y) = \texttt{true}\).
We convert a subset (Finset) \(S \subseteq V\) to a binary indicator vector in \(\mathbb {Z}_2\):
For a subset \(S\) and element \(v\), we have \(\texttt{subsetToVector}(S)(v) = 1 \Leftrightarrow v \in S\).
By simplification using the definition. For the forward direction, assume \(\texttt{subsetToVector}(S)(v) = 1\). We consider whether \(v \in S\). If \(v \in S\), we are done. If \(v \notin S\), then by definition \(\texttt{subsetToVector}(S)(v) = 0\), so \(0 = 1\), which is a contradiction verified by computation. For the reverse direction, if \(v \in S\), then by definition \(\texttt{subsetToVector}(S)(v) = 1\).
For a subset \(S\) and element \(v\), we have \(\texttt{subsetToVector}(S)(v) = 0 \Leftrightarrow v \notin S\).
By simplification using the definition. For the forward direction, assume \(\texttt{subsetToVector}(S)(v) = 0\). We consider whether \(v \in S\). If \(v \in S\), then by definition \(\texttt{subsetToVector}(S)(v) = 1\), so \(1 = 0\), which is a contradiction verified by computation. If \(v \notin S\), we are done. For the reverse direction, if \(v \notin S\), then by definition \(\texttt{subsetToVector}(S)(v) = 0\).
For subsets \(S, T \subseteq V\) and element \(v\):
where addition is in \(\mathbb {Z}_2\).
By simplification using the definition and membership in symmetric difference. We consider four cases based on whether \(v \in S\) and \(v \in T\):
Case \(v \in S\) and \(v \in T\): The symmetric difference excludes \(v\), so the left side is 0. The right side is \(1 + 1 = 0\) in \(\mathbb {Z}_2\), verified by computation.
Case \(v \in S\) and \(v \notin T\): The symmetric difference includes \(v\), so the left side is 1. The right side is \(1 + 0 = 1\), verified by computation.
Case \(v \notin S\) and \(v \in T\): The symmetric difference includes \(v\), so the left side is 1. The right side is \(0 + 1 = 1\), verified by computation.
Case \(v \notin S\) and \(v \notin T\): The symmetric difference excludes \(v\), so the left side is 0. The right side is \(0 + 0 = 0\), verified by computation.
For any element \(v\), we have \(\texttt{subsetToVector}(\emptyset )(v) = 0\).
By simplification using the definition and the fact that \(v \notin \emptyset \), the result follows directly.
For subsets \(S, T \subseteq V\) and element \(v\):
By simplification using the definition and membership in intersection. We consider four cases based on whether \(v \in S\) and \(v \in T\), and in each case the equality holds by the definitions and properties of multiplication.
The parameters of a stabilizer code in \([[n, k, d]]\) notation consist of:
\(n\): number of physical qubits
\(k\): number of logical qubits (code encodes a \(2^k\)-dimensional space)
\(d\): code distance
A proof that \(k \leq n\) (can’t encode more logical qubits than physical)
The dimension of the code space for parameters with \(k\) logical qubits is \(2^k\).
The number of independent stabilizer generators for an \([[n, k, d]]\) code is \(n - k\).
The \([[7, 1, 3]]\) Steane code parameters: \(n = 7\), \(k = 1\), \(d = 3\).
The \([[5, 1, 3]]\) perfect code parameters: \(n = 5\), \(k = 1\), \(d = 3\).
A code with distance \(d\) can correct up to \(\lfloor (d-1)/2\rfloor \) errors.
The Steane code can correct 1 error: \(\texttt{correctableErrors}(\texttt{steaneCode}) = 1\).
This holds by reflexivity. We compute \((3 - 1) / 2 = 2 / 2 = 1\).
The perfect code can correct 1 error: \(\texttt{correctableErrors}(\texttt{perfectCode}) = 1\).
This holds by reflexivity. We compute \((3 - 1) / 2 = 2 / 2 = 1\).
Two single-qubit Paulis commute if and only if they are equal or one is the identity:
\(I\) commutes with everything
\(X\), \(Y\), \(Z\) each commute only with themselves and \(I\)
Different non-identity Paulis anticommute
The anticommuting overlap of two Pauli strings \(P\) and \(Q\) is the number of positions where both have non-trivial, non-commuting Paulis:
Two Pauli strings commute if and only if their anticommuting overlap is even:
For any Pauli string \(P\), the identity string commutes with \(P\).
We unfold the definitions of \(\texttt{pauliStringsCommute}\) and \(\texttt{anticommutingOverlap}\). By simplification using the definitions of identity and \(\texttt{singleCommute}\), we convert the goal to showing \(0 \mod 2 = 0\). To show the anticommuting overlap is 0, we show the filter is empty: for any index \(i\) in the universe, \(\texttt{singleCommute}(I, P(i)) = \texttt{true}\) by the definition of \(\texttt{singleCommute}\), verified by computation.
For any Pauli string \(P\), we have \(P\) commutes with \(P\).
We unfold the definitions of \(\texttt{pauliStringsCommute}\) and \(\texttt{anticommutingOverlap}\). We convert the goal to showing \(0 \mod 2 = 0\). To show the anticommuting overlap is 0, we show the filter is empty: for any index \(i\) in the universe, we need \(\texttt{singleCommute}(P(i), P(i)) = \texttt{true}\). By simplification and case analysis on \(P(i)\), in each case (\(I\), \(X\), \(Y\), \(Z\)), the result holds by reflexivity since each Pauli commutes with itself.
A phase factor is an element of \(\mathbb {Z}/4\mathbb {Z}\), representing powers of the imaginary unit \(i^\sigma \) where \(\sigma \in \{ 0, 1, 2, 3\} \) corresponds to \(1\), \(i\), \(-1\), \(-i\) respectively.
The trivial phase is \(i^0 = 1\), represented by the element \(0 \in \mathbb {Z}/4\mathbb {Z}\).
The imaginary phase is \(i^1 = i\), represented by the element \(1 \in \mathbb {Z}/4\mathbb {Z}\).
The negative phase is \(i^2 = -1\), represented by the element \(2 \in \mathbb {Z}/4\mathbb {Z}\).
The negative imaginary phase is \(i^3 = -i\), represented by the element \(3 \in \mathbb {Z}/4\mathbb {Z}\).
The multiplication of phases is defined by \(i^a \cdot i^b = i^{(a+b) \bmod 4}\). Formally, for phases \(a, b \in \mathbb {Z}/4\mathbb {Z}\), their product is \((a + b) \bmod 4\).
For all phases \(a, b\), we have \(\mathrm{mul}(a, b) = \mathrm{mul}(b, a)\).
By the definition of phase multiplication, \(\mathrm{mul}(a, b) = (a + b) \bmod 4\) and \(\mathrm{mul}(b, a) = (b + a) \bmod 4\). Since addition in \(\mathbb {Z}\) is commutative, we have \(a + b = b + a\), and thus the two expressions are equal by congruence.
For all phases \(a\), we have \(\mathrm{mul}(\mathrm{one}, a) = a\).
By simplification using the definitions of \(\mathrm{mul}\) and \(\mathrm{one}\), we have \(\mathrm{mul}(\mathrm{one}, a) = (0 + a) \bmod 4 = a \bmod 4\). Since \(a \in \{ 0, 1, 2, 3\} \), we have \(a \bmod 4 = a\).
For all phases \(a\), we have \(\mathrm{mul}(a, \mathrm{one}) = a\).
Rewriting using commutativity of phase multiplication, we have \(\mathrm{mul}(a, \mathrm{one}) = \mathrm{mul}(\mathrm{one}, a)\). The result then follows from the left identity theorem.
The phase shift by \(n\) units is defined as \(\mathrm{shift}(p, n) = (p + n) \bmod 4\).
A stabilizer check operator on \(n\) qubits is a structure consisting of:
\(S_X \subseteq \{ 0, \ldots , n-1\} \): the X-type support (qubits where \(X\) or \(Y\) acts),
\(S_Z \subseteq \{ 0, \ldots , n-1\} \): the Z-type support (qubits where \(Z\) or \(Y\) acts),
\(\sigma \in \{ 0, 1, 2, 3\} \): the phase factor.
This represents the operator \(i^\sigma \cdot \prod _{v \in S_X} X_v \cdot \prod _{v \in S_Z} Z_v\). When both \(X\) and \(Z\) act on a site \(v\) (i.e., \(v \in S_X \cap S_Z\)), we obtain \(Y_v = iX_vZ_v\).
The identity check operator on \(n\) qubits is defined by \(S_X = \emptyset \), \(S_Z = \emptyset \), and phase \(\sigma = 0\) (i.e., \(i^0 = 1\)).
The weight of a stabilizer check \(s\) is the number of non-identity sites:
The underlying Pauli string of a stabilizer check \(s\) (ignoring phase) is the function that maps each qubit \(i\) to:
\(Y\) if \(i \in S_X \cap S_Z\) (both X and Z act),
\(X\) if \(i \in S_X \setminus S_Z\) (only X acts),
\(Z\) if \(i \in S_Z \setminus S_X\) (only Z acts),
\(I\) if \(i \notin S_X \cup S_Z\) (neither acts).
Two stabilizer checks \(s_1\) and \(s_2\) have the same Pauli action if they have identical supports:
This means they represent the same operator up to a global phase.
A stabilizer check \(s\) has trivial Pauli action if both supports are empty:
Such an operator acts as the identity (up to a global phase).
The weight of the identity check operator is zero: \(\mathrm{weight}(\mathrm{identity}_n) = 0\).
By simplification using the definitions of identity and weight, we have \(\mathrm{weight}(\mathrm{identity}_n) = |\emptyset \cup \emptyset | = |\emptyset | = 0\).
The underlying Pauli string of the identity check is the identity Pauli string.
By extensionality, it suffices to show equality for an arbitrary qubit \(i\). By simplification using the definitions of identity and toPauliString, since \(i \notin \emptyset \), the result is \(I\), which equals the identity Pauli string at position \(i\). This holds by reflexivity.
The identity check operator has trivial Pauli action.
This follows directly by reflexivity: both \(S_X = \emptyset \) and \(S_Z = \emptyset \) hold by definition of the identity check.
Two stabilizer checks \(s_1\) and \(s_2\) commute if the total overlap count is even:
This captures the symplectic inner product condition for Pauli operator commutativity.
For stabilizer checks \(s_1\) and \(s_2\), we have \(\mathrm{commutes}(s_1, s_2) \Leftrightarrow \mathrm{commutes}(s_2, s_1)\).
We prove both directions. For the forward direction, assume \(\mathrm{commutes}(s_1, s_2)\) holds. By commutativity of set intersection, we have \(|s_1.S_X \cap s_2.S_Z| = |s_2.S_Z \cap s_1.S_X|\) and \(|s_1.S_Z \cap s_2.S_X| = |s_2.S_X \cap s_1.S_Z|\). Rewriting and using commutativity of addition, the hypothesis gives the result. The reverse direction is symmetric.
Every stabilizer check commutes with itself: \(\mathrm{commutes}(s, s)\) for all \(s\).
By simplification using the definition of commutativity. We have \(|s.S_X \cap s.S_Z| + |s.S_Z \cap s.S_X| = 2 \cdot |s.S_X \cap s.S_Z|\) by commutativity of set intersection. Since \(2k \bmod 2 = 0\) for any \(k\), the result follows by the divisibility property.
The identity check commutes with every stabilizer check: \(\mathrm{commutes}(\mathrm{identity}_n, s)\) for all \(s\).
By simplification using the definitions, we have \(|\emptyset \cap s.S_Z| + |\emptyset \cap s.S_X| = 0 + 0 = 0\), and \(0 \bmod 2 = 0\).
The XZ-overlap of two checks \(s_1\) and \(s_2\) counts the sites where \(s_1\) has X-support and \(s_2\) has Z-support:
The product of two stabilizer checks \(s_1\) and \(s_2\) is defined by:
\(S_X = s_1.S_X \triangle s_2.S_X\) (symmetric difference),
\(S_Z = s_1.S_Z \triangle s_2.S_Z\) (symmetric difference),
Phase: The base phase is \(s_1.\sigma + s_2.\sigma \). The extra phase contribution comes from Y-interactions: when \(s_1\) has X at site \(v\) and \(s_2\) has Z, we get \(XZ = iY\) (contributing \(+1\)); when \(s_1\) has Z and \(s_2\) has X, we get \(ZX = -iY\) (contributing \(+3 \equiv -1 \bmod 4\)). The total extra phase is \((|s_1.S_X \cap s_2.S_Z| + 3 \cdot |s_1.S_Z \cap s_2.S_X|) \bmod 4\).
For any check \(s\), the product \(\mathrm{mul}(\mathrm{identity}_n, s)\) has the same Pauli action as \(s\).
By simplification using the definitions of mul, identity, and samePauliAction. We verify both conditions: \(\emptyset \triangle s.S_X = s.S_X\) and \(\emptyset \triangle s.S_Z = s.S_Z\) by properties of symmetric difference with the empty set.
For any check \(s\), the product \(\mathrm{mul}(s, \mathrm{identity}_n)\) has the same Pauli action as \(s\).
By simplification using the definitions of mul, identity, and samePauliAction. We verify both conditions: \(s.S_X \triangle \emptyset = s.S_X\) and \(s.S_Z \triangle \emptyset = s.S_Z\) by properties of symmetric difference with the empty set.
For any check \(s\), we have \(\mathrm{mul}(\mathrm{identity}_n, s) = s\).
By simplification using the definitions of mul and identity, and applying the left identity property of phase multiplication. By extensionality, we verify the supports coincide using \(\emptyset \triangle A = A\) and the phase equals \(s.\sigma \) since the overlap terms are zero.
For any check \(s\), we have \(\mathrm{mul}(s, \mathrm{identity}_n) = s\).
By simplification using the definitions of mul and identity, and applying the right identity property of phase multiplication. By extensionality:
For the X-support: \(s.S_X \triangle \emptyset = s.S_X\) by properties of symmetric difference.
For the Z-support: \(s.S_Z \triangle \emptyset = s.S_Z\) by properties of symmetric difference.
For the phase: Since the overlaps \(|s.S_X \cap \emptyset | = 0\) and \(|s.S_Z \cap \emptyset | = 0\), the extra phase is 0, and thus the final phase equals \(s.\sigma \) since \(s.\sigma \bmod 4 = s.\sigma \) for \(s.\sigma {\lt} 4\).
Given a family of checks \(\{ \mathrm{checks}_i\} _{i {\lt} m}\) and a finite subset \(T \subseteq \{ 0, \ldots , m-1\} \), the product of checks over \(T\) is defined by folding multiplication over the list representation of \(T\):
with the identity check as the base case.
An \([[n, k]]\) stabilizer code is a structure consisting of:
A proof that \(k {\lt} n\) (number of logical qubits is strictly less than physical qubits),
A family of \(n - k\) stabilizer check generators \(\{ \mathrm{checks}_i\} _{i {\lt} n-k}\),
Commutativity: All checks mutually commute, i.e., \(\mathrm{commutes}(\mathrm{checks}_i, \mathrm{checks}_j)\) for all \(i, j\),
Independence: Only the trivial product gives identity Pauli action, i.e., for all \(T \subseteq \{ 0, \ldots , n-k-1\} \), if \(\prod _{i \in T} \mathrm{checks}_i\) has trivial action, then \(T = \emptyset \).
For an \([[n, k]]\) stabilizer code \(C\), the number of stabilizer generators is \(n - k\).
For an \([[n, k]]\) stabilizer code \(C\), the code dimension is \(2^k\). This represents the dimension of the stabilized subspace in the Hilbert space formulation.
For an \([[n, k]]\) stabilizer code \(C\), the number of physical qubits is \(n\).
For an \([[n, k]]\) stabilizer code \(C\), the number of logical qubits is \(k\).
For an \([[n, k]]\) stabilizer code \(C\) and index \(i {\lt} n - k\), the function \(\mathrm{getCheck}(C, i)\) returns the \(i\)-th check operator.
For any \([[n, k]]\) stabilizer code \(C\), we have \(k {\lt} n\).
This follows directly from the \(k\_ lt\_ n\) field of the stabilizer code structure.
For any \([[n, k]]\) stabilizer code \(C\) and index \(i {\lt} n - k\), the \(i\)-th check commutes with itself.
This follows directly from the general theorem that every stabilizer check commutes with itself.
For any \([[n, k]]\) stabilizer code \(C\) and indices \(i, j {\lt} n - k\), we have \(\mathrm{commutes}(C.\mathrm{checks}_i, C.\mathrm{checks}_j) \Leftrightarrow \mathrm{commutes}(C.\mathrm{checks}_j, C.\mathrm{checks}_i)\).
This follows directly from the symmetry of the commutativity relation for stabilizer checks.
For an \([[n, k]]\) stabilizer code \(C\), the maximum check weight is:
or \(0\) if \(n - k = 0\).
For an \([[n, k]]\) stabilizer code \(C\) and qubit \(v {\lt} n\), the qubit degree is the number of checks in which qubit \(v\) participates:
For an \([[n, k]]\) stabilizer code \(C\), the maximum qubit degree is:
or \(0\) if \(n = 0\).
An \([[n, k]]\) stabilizer code \(C\) is \((w, \Delta )\)-LDPC (Low-Density Parity-Check) if:
Each check has weight at most \(w\): \(\mathrm{weight}(C.\mathrm{checks}_i) \leq w\) for all \(i\),
Each qubit participates in at most \(\Delta \) checks: \(\mathrm{qubitDegree}(C, v) \leq \Delta \) for all \(v\).
A Pauli operator \(P\) commutes with an \([[n, k]]\) stabilizer code \(C\) if \(P\) commutes with all check operators:
A Pauli operator \(P\) is a stabilizer element of code \(C\) if it has the same Pauli action as some product of checks:
An \([[n, k]]\) stabilizer code \(C\) has distance at least \(d\) if every Pauli operator \(P\) that commutes with \(C\) but is not a stabilizer element has weight at least \(d\):
An \([[n, k, d]]\) stabilizer code is an \([[n, k]]\) stabilizer code together with a proof that it has distance at least \(d\).
For any family of checks, the product over the empty set is the identity check:
By simplification using the definition of productOfChecks: when the input set is empty, its multiset value is empty, the list is nil, and folding over nil returns the identity check.
For any family of checks, the product over the empty set has trivial Pauli action.
Rewriting using the theorem that the product over the empty set equals the identity check, the result follows from the theorem that the identity check has trivial action.
For any \([[n, k]]\) stabilizer code \(C\), the identity check is a stabilizer element.
We use the empty set as witness: taking \(T = \emptyset \), we have \(\prod _{i \in \emptyset } C.\mathrm{checks}_i = \mathrm{identity}_n\) by the product of empty set theorem, and the identity has the same Pauli action as itself by reflexivity.
For any finite sets \(A\), \(B\), and \(S\):
We use that \(A \triangle B = (A \setminus B) \cup (B \setminus A)\), which is a disjoint union.
First, we establish that \((A \setminus B) \cap S\) and \((B \setminus A) \cap S\) are disjoint. By the definition of disjointness, for any \(x \in (A \setminus B) \cap S\) and \(y \in (B \setminus A) \cap S\), if \(x = y\), then \(x \in A \setminus B\) and \(x \in B \setminus A\), which is impossible since \(x \notin B\) and \(x \in B\) would both hold. Thus these sets are disjoint.
Next, we show that \((A \triangle B) \cap S = ((A \setminus B) \cap S) \cup ((B \setminus A) \cap S)\). By extensionality, \(x \in (A \triangle B) \cap S\) iff \(x \in A \triangle B\) and \(x \in S\). By the definition of symmetric difference, either \(x \in A \setminus B\) or \(x \in B \setminus A\). In the first case, \(x \in (A \setminus B) \cap S\); in the second, \(x \in (B \setminus A) \cap S\). Conversely, if \(x\) is in either of these sets, then \(x \in (A \triangle B) \cap S\).
Using the disjoint union property, \(|(A \triangle B) \cap S| = |(A \setminus B) \cap S| + |(B \setminus A) \cap S|\).
Now we establish the auxiliary facts. For any set \(A\), we have \(|A \cap S| = |(A \setminus B) \cap S| + |A \cap B \cap S|\). This follows because \((A \setminus B) \cap S\) and \(A \cap B \cap S\) are disjoint (if \(x\) is in both, then \(x \notin B\) and \(x \in B\), contradiction), and their union equals \(A \cap S\) (by case analysis on whether \(x \in B\)). Similarly, \(|B \cap S| = |(B \setminus A) \cap S| + |A \cap B \cap S|\).
Therefore:
By integer arithmetic, adding \(2|A \cap B \cap S|\) does not change the result modulo 2, so:
If \(A\) commutes with \(D\) and \(B\) commutes with \(D\), then \(\mathrm{mul}(A, B)\) commutes with \(D\).
Unfolding the definition of commutativity at all occurrences, and simplifying using the definition of check multiplication:
We need to prove:
Using the lemma about symmetric difference intersection cardinality:
Adding these and rearranging:
where we used the hypotheses that \(A\) commutes with \(D\) and \(B\) commutes with \(D\). By integer arithmetic, this completes the proof.
For any \([[n, k]]\) stabilizer code \(C\), index \(i {\lt} n - k\), and list \(L\) of indices:
where \(\mathrm{fold}(L)\) is the right fold of check multiplication over \(L\) with identity base.
We proceed by induction on \(L\).
Base case (\(L = []\)): By simplification, the fold over the empty list is the identity check. By the theorem that identity commutes with everything, the result follows.
Inductive step (\(L = x :: xs\)): By simplification, the fold over \(x :: xs\) equals \(\mathrm{mul}(C.\mathrm{checks}_x, \mathrm{fold}(xs))\). We apply the theorem that multiplication preserves commutativity with two sub-goals:
\(C.\mathrm{checks}_x\) commutes with \(C.\mathrm{checks}_i\): This follows from the commutativity property of the stabilizer code.
\(\mathrm{fold}(xs)\) commutes with \(C.\mathrm{checks}_i\): This is the induction hypothesis.
If \(P\) is a stabilizer element of code \(C\), then \(P\) commutes with \(C\).
Let \(i {\lt} n - k\) be arbitrary. We need to show \(\mathrm{commutes}(P, C.\mathrm{checks}_i)\).
From the hypothesis that \(P\) is a stabilizer element, we obtain \(T\) and \(h_T\) such that \(\mathrm{samePauliAction}(\prod _{j \in T} C.\mathrm{checks}_j, P)\) holds.
First, we show that the product commutes with \(C.\mathrm{checks}_i\). Unfolding the definition of productOfChecks, this reduces to showing the list fold commutes, which follows from the list fold commutes lemma.
Since commutativity only depends on the Pauli action (the supports), not the phase, and \(P\) has the same Pauli action as the product, we can substitute: unfolding the commutativity and samePauliAction definitions, we rewrite using the equalities \(P.S_X = (\prod _{j \in T} C.\mathrm{checks}_j).S_X\) and \(P.S_Z = (\prod _{j \in T} C.\mathrm{checks}_j).S_Z\), and the result follows from the product’s commutativity.
For any \(n\), \(\mathrm{weight}(\mathrm{identity}_n) = 0\).
This follows directly from the identity weight theorem.
For any \([[n, k]]\) stabilizer code \(C\) and \((w, \Delta )\)-LDPC property, we have \(0 \leq w\) and \(0 \leq \Delta \).
This follows immediately since natural numbers are non-negative.
If a stabilizer check \(s\) has weight \(0\), then it has trivial Pauli action.
By simplification using the definition of weight. The hypothesis \(\mathrm{weight}(s) = 0\) means \(|s.S_X \cup s.S_Z| = 0\). Using the theorem that a finite set has cardinality zero iff it is empty, we get \(s.S_X \cup s.S_Z = \emptyset \).
By simplification using the definition of trivial action. We verify both conditions:
For \(s.S_X = \emptyset \): By extensionality, for any \(x\), we show \(x \notin s.S_X\). Suppose for contradiction that \(x \in s.S_X\). Then \(x \in s.S_X \cup s.S_Z\) by left union membership. But we have \(s.S_X \cup s.S_Z = \emptyset \), so \(x \in \emptyset \), contradicting that nothing is in the empty set.
For \(s.S_Z = \emptyset \): By extensionality, for any \(x\), we show \(x \notin s.S_Z\). Suppose for contradiction that \(x \in s.S_Z\). Then \(x \in s.S_X \cup s.S_Z\) by right union membership. But we have \(s.S_X \cup s.S_Z = \emptyset \), so \(x \in \emptyset \), contradicting that nothing is in the empty set.
1.1 Logical Operator (Definition 2)
Let \(C\) be an \([[n, k, d]]\) stabilizer code with check operators \(\{ s_i\} \).
A logical operator is a Pauli operator \(L\) such that:
\(L\) commutes with all stabilizer checks: \([L, s_i] = 0\) for all \(i\).
\(L\) is not a product of stabilizer checks: \(L \notin \langle s_1, \ldots , s_{n-k} \rangle \).
A logical representative is a specific choice of Pauli operator \(L\) representing a logical operator. Two logical representatives \(L\) and \(L'\) are equivalent if \(L' = L \cdot \prod _{i \in T} s_i\) for some \(T \subseteq \{ 1, \ldots , n-k\} \).
The weight of a logical operator is \(|L| = |S_X(L) \cup S_Z(L)|\), the number of qubits on which \(L\) acts non-trivially.
The code distance satisfies \(d = \min \{ |L| : L \text{ is a logical operator}\} \).
By choosing an appropriate single-qubit basis for each physical qubit, any logical operator can be assumed to be X-type, i.e., \(L = \prod _{v \in L} X_v\) for some \(L \subseteq \{ 1, \ldots , n\} \).
1.1.1 Logical Operator Definition
A logical operator for a stabilizer code \(C\) is a structure consisting of:
An underlying Pauli operator \(L\) (as a stabilizer check structure).
A proof that \(L\) commutes with all stabilizer checks: \(\texttt{commuteWithCode}(C, L)\).
A proof that \(L\) is not a stabilizer element: \(\neg \texttt{isStabilizerElement}(C, L)\).
The weight of a logical operator \(L\) is defined as \(|L| = |S_X(L) \cup S_Z(L)|\), the number of qubits on which \(L\) acts non-trivially.
The X-support of a logical operator \(L\) is the set of qubits where \(L\) has an \(X\) or \(Y\) component.
The Z-support of a logical operator \(L\) is the set of qubits where \(L\) has a \(Z\) or \(Y\) component.
The conversion of a logical operator \(L\) to a Pauli string (ignoring phase).
If a stabilizer code \(C\) has distance \(d\), then every logical operator \(L\) satisfies \(|L| \geq d\).
This follows directly from the definition of code distance: the distance property \(\texttt{hasDistance}(C, d)\) states that every non-stabilizer operator that commutes with all checks has weight at least \(d\). Applying this to \(L.\texttt{operator}\) with \(L.\texttt{commutes\_ with\_ checks}\) and \(L.\texttt{not\_ stabilizer}\) yields the result.
1.1.2 Logical Representatives and Equivalence
Two logical operators \(L_1\) and \(L_2\) are equivalent if there exists a subset \(T \subseteq \{ 1, \ldots , n-k\} \) such that \(L_2\) has the same Pauli action as \(L_1 \cdot \prod _{i \in T} s_i\), where \(s_i\) are the stabilizer checks of code \(C\).
For any stabilizer code \(C\) and logical operator \(L\), we have \(\texttt{LogicalEquiv}(C, L, L)\).
We take \(T = \emptyset \). By the theorem on empty product of checks, \(\texttt{productOfChecks}(C.\texttt{checks}, \emptyset )\) is the identity. Then \(L \cdot \texttt{identity} = L\) by the multiplication identity property. The same Pauli action follows by reflexivity: \(L.\texttt{supportX} = L.\texttt{supportX}\) and \(L.\texttt{supportZ} = L.\texttt{supportZ}\).
For any finite set \(A\), we have \(A \triangle A = \emptyset \).
By extensionality, it suffices to show that for all \(x\), \(x \in A \triangle A \Leftrightarrow x \in \emptyset \). By definition of symmetric difference, \(x \in A \triangle A\) iff \((x \in A \land x \notin A) \lor (x \in A \land x \notin A)\), which is always false. Hence \(A \triangle A = \emptyset \).
For any finite set \(A\), we have \(A \triangle \emptyset = A\).
By extensionality, for any \(x\): \(x \in A \triangle \emptyset \) iff \((x \in A \land x \notin \emptyset ) \lor (x \in \emptyset \land x \notin A)\). Since \(x \notin \emptyset \) is always true, this simplifies to \(x \in A\). Hence \(A \triangle \emptyset = A\).
For stabilizer checks \(s_1\) and \(s_2\), we have \((s_1 \cdot s_2).\texttt{supportX} = s_1.\texttt{supportX} \triangle s_2.\texttt{supportX}\).
This holds by reflexivity, as the definition of \(\texttt{StabilizerCheck.mul}\) defines the X-support of the product to be the symmetric difference of the X-supports.
For stabilizer checks \(s_1\) and \(s_2\), we have \((s_1 \cdot s_2).\texttt{supportZ} = s_1.\texttt{supportZ} \triangle s_2.\texttt{supportZ}\).
This holds by reflexivity, as the definition of \(\texttt{StabilizerCheck.mul}\) defines the Z-support of the product to be the symmetric difference of the Z-supports.
1.1.3 X-Type Logical Operators
An X-type Pauli operator on \(n\) qubits with support set \(S \subseteq \{ 1, \ldots , n\} \) is a stabilizer check with:
\(\texttt{supportX} = S\)
\(\texttt{supportZ} = \emptyset \)
\(\texttt{phase} = 1\)
This represents the operator \(L = \prod _{v \in S} X_v\).
The weight of an X-type Pauli operator with support \(S\) equals \(|S|\).
By simplification using the definitions of \(\texttt{XTypePauli}\) and \(\texttt{StabilizerCheck.weight}\): the weight is \(|S_X \cup S_Z| = |S \cup \emptyset | = |S|\).
An X-type logical operator for a stabilizer code \(C\) is a structure consisting of:
A support set \(L \subseteq \{ 1, \ldots , n\} \).
A proof that the X-type operator \(\prod _{v \in L} X_v\) commutes with all checks.
A proof that the X-type operator is not a stabilizer element.
An X-type logical operator can be converted to a general logical operator by taking the X-type Pauli operator as the underlying operator.
The weight of an X-type logical operator \(L\) is defined as the cardinality of its support set \(|L.\texttt{support}|\).
For an X-type logical operator \(L\), the X-type weight equals the general logical operator weight: \(L.\texttt{weight} = L.\texttt{toLogicalOperator}.\texttt{weight}\).
By simplification using the definitions of X-type weight, logical operator weight, the conversion to logical operator, and the X-type Pauli weight theorem.
1.1.4 Distance and Minimum Weight
A stabilizer code \(C\) has minimum distance \(d\) if:
\(C\) has distance \(d\) (all logical operators have weight \(\geq d\)), and
There exists a logical operator \(L\) with weight exactly \(d\).
If a stabilizer code \(C\) has distance \(d\), then every logical operator \(L\) satisfies \(|L| \geq d\).
This follows directly from applying the distance property \(\texttt{hasDistance}(C, d)\) to the operator \(L.\texttt{operator}\), using \(L.\texttt{commutes\_ with\_ checks}\) and \(L.\texttt{not\_ stabilizer}\).
1.1.5 Commutation Lemmas
If \(L_1\) commutes with all checks of code \(C\) and \(L_2\) has the same Pauli action as \(L_1\), then \(L_2\) also commutes with all checks of \(C\).
Let \(i\) be an arbitrary check index. We have that \(L_1\) commutes with check \(i\) by hypothesis. Unfolding the definition of commutation, this depends only on the X-support and Z-support. Since \(L_1\) and \(L_2\) have the same Pauli action, they have the same X-support and Z-support. Rewriting using these equalities, we conclude that \(L_2\) commutes with check \(i\).
If \(L_2\) is equivalent to \(L_1\) (i.e., \(L_2\) has same Pauli action as \(L_1 \cdot S_T\) for some stabilizer product \(S_T\)), and \(L_1\) commutes with code \(C\), then \(L_2\) also commutes with \(C\).
From the equivalence hypothesis, we obtain a subset \(T\) such that \(L_2\) has the same Pauli action as \(L_1 \cdot \texttt{productOfChecks}(C.\texttt{checks}, T)\).
We first show that \(L_1 \cdot \texttt{productOfChecks}(C.\texttt{checks}, T)\) commutes with all checks. Let \(j\) be an arbitrary check index. We have:
\(L_1\) commutes with check \(j\) by hypothesis.
The product of checks \(\texttt{productOfChecks}(C.\texttt{checks}, T)\) is a stabilizer element (by definition), so it commutes with check \(j\) by the theorem that stabilizer elements commute with all checks.
By the theorem that products of commuting operators commute, \(L_1 \cdot S_T\) commutes with check \(j\).
Since \(L_2\) has the same Pauli action as \(L_1 \cdot S_T\), and commutation only depends on the X-support and Z-support (which are equal by the same Pauli action property), we conclude that \(L_2\) commutes with check \(i\) for all \(i\).
1.1.6 Helper Lemmas
For any X-type Pauli operator with support \(S\), the Z-support is empty: \((X_S).\texttt{supportZ} = \emptyset \).
This holds by reflexivity from the definition of \(\texttt{XTypePauli}\), which explicitly sets \(\texttt{supportZ} = \emptyset \).
For any X-type Pauli operator with support \(S\), the phase is one: \((X_S).\texttt{phase} = 1\).
This holds by reflexivity from the definition of \(\texttt{XTypePauli}\), which explicitly sets \(\texttt{phase} = \texttt{Phase.one}\).
The X-type Pauli operator with empty support is the identity: \(X_\emptyset = I\).
By simplification using the definitions of \(\texttt{XTypePauli}\) and \(\texttt{StabilizerCheck.identity}\): both have \(\texttt{supportX} = \emptyset \), \(\texttt{supportZ} = \emptyset \), and \(\texttt{phase} = 1\).
For any qubit \(v\), the X-type Pauli operator \(X_{\{ v\} }\) has weight 1.
By simplification using the X-type Pauli weight theorem and the fact that \(|\{ v\} | = 1\).
For any logical operator \(L\), we have \(0 \leq |L|\).
This follows from the fact that natural numbers are non-negative: \(0 \leq n\) for all \(n \in \mathbb {N}\).
For any X-type Pauli operator with support \(S\), the X-support is exactly \(S\): \((X_S).\texttt{supportX} = S\).
This holds by reflexivity from the definition of \(\texttt{XTypePauli}\), which explicitly sets \(\texttt{supportX} = S\).
For X-type Pauli operators with supports \(S_1\) and \(S_2\), the X-support of their product is the symmetric difference: \((X_{S_1} \cdot X_{S_2}).\texttt{supportX} = S_1 \triangle S_2\).
By simplification using the lemma that multiplication X-support is symmetric difference and the lemma that X-type Pauli X-support equals the support set.
An X-type Pauli operator with support \(S\) commutes with a stabilizer check \(s\) if and only if the cardinality of \(S \cap s.\texttt{supportZ}\) is even:
Unfolding the definition of commutation, two Pauli operators commute iff \((|S_X^{(1)} \cap S_Z^{(2)}| + |S_Z^{(1)} \cap S_X^{(2)}|) \equiv 0 \pmod{2}\). For an X-type Pauli operator, \(S_Z = \emptyset \), so \(|\emptyset \cap s.\texttt{supportX}| = 0\). The condition reduces to \(|S \cap s.\texttt{supportZ}| \equiv 0 \pmod{2}\).
A Z-type Pauli operator on \(n\) qubits with support set \(S \subseteq \{ 1, \ldots , n\} \) is a stabilizer check with:
\(\texttt{supportX} = \emptyset \)
\(\texttt{supportZ} = S\)
\(\texttt{phase} = 1\)
This represents the operator \(L = \prod _{v \in S} Z_v\).
For any Z-type Pauli operator with support \(S\), the X-support is empty: \((Z_S).\texttt{supportX} = \emptyset \).
This holds by reflexivity from the definition of \(\texttt{ZTypePauli}\), which explicitly sets \(\texttt{supportX} = \emptyset \).
For any Z-type Pauli operator with support \(S\), the Z-support is exactly \(S\): \((Z_S).\texttt{supportZ} = S\).
This holds by reflexivity from the definition of \(\texttt{ZTypePauli}\), which explicitly sets \(\texttt{supportZ} = S\).
The weight of a Z-type Pauli operator with support \(S\) equals \(|S|\).
By simplification using the definitions of \(\texttt{ZTypePauli}\) and \(\texttt{StabilizerCheck.weight}\): the weight is \(|S_X \cup S_Z| = |\emptyset \cup S| = |S|\).
A Z-type Pauli operator with support \(S\) commutes with a stabilizer check \(s\) if and only if the cardinality of \(S \cap s.\texttt{supportX}\) is even:
Unfolding the definition of commutation, two Pauli operators commute iff \((|S_X^{(1)} \cap S_Z^{(2)}| + |S_Z^{(1)} \cap S_X^{(2)}|) \equiv 0 \pmod{2}\). For a Z-type Pauli operator, \(S_X = \emptyset \), so \(|\emptyset \cap s.\texttt{supportZ}| = 0\). The condition reduces to \(|S \cap s.\texttt{supportX}| \equiv 0 \pmod{2}\).
1.2 Gauging Graph (Definition 3)
Let \(C\) be an \([[n, k, d]]\) stabilizer code and let \(L = \prod _{v \in \mathcal{L}} X_v\) be an \(X\)-type logical operator with support \(\mathcal{L}\).
A gauging graph for \(L\) is a connected graph \(G = (V, E)\) such that:
Vertices: \(V \supseteq \mathcal{L}\), with an isomorphism identifying \(\mathcal{L}\) with a subset of vertices.
Connectivity: \(G\) is connected.
Edge qubits: Each edge \(e \in E\) corresponds to an auxiliary qubit.
The graph \(G\) may contain dummy vertices \(V \setminus \mathcal{L}\), which correspond to auxiliary qubits initialized in the \(|+\rangle \) state and on which \(X\) is measured with certain outcome \(+1\).
Graph parameters:
\(|V|\) = number of vertices (includes support of \(L\) plus dummy vertices)
\(|E|\) = number of edges (equals number of auxiliary qubits)
The cycle rank of \(G\) is \(|E| - |V| + 1\) (number of independent cycles)
1.2.1 Gauging Graph Definition
A gauging graph for an \(X\)-type logical operator \(L\) of a stabilizer code \(C\) is a structure consisting of:
A finite vertex type \(V\) with decidable equality
An underlying simple graph structure \(G\) on \(V\) with decidable adjacency
An injective embedding \(\iota : \operatorname {supp}(L) \hookrightarrow V\) of the logical support into vertices
The graph \(G\) is connected
The number of vertices in a gauging graph \(G\) is defined as \(|V| = \operatorname {card}(V)\).
The number of edges in a gauging graph \(G\) is defined as \(|E| = \operatorname {card}(E)\), where \(E\) is the edge set of the graph. This equals the number of auxiliary qubits.
The cycle rank (also known as the cyclomatic complexity or first Betti number) of a gauging graph \(G\) is defined as:
This counts the number of independent cycles in the graph.
The support vertices of a gauging graph \(G\) is the set of vertices in the image of the support embedding:
The dummy vertices of a gauging graph \(G\) are the vertices not in the support image:
The number of dummy vertices is \(|\operatorname {dummyVertices}(G)|\).
The support size of a gauging graph is the cardinality of the logical operator’s support: \(|\operatorname {supp}(L)|\).
1.2.2 Basic Properties
For a gauging graph \(G\), the cardinality of the support vertices equals the support size:
By definition of support vertices and support size, we have \(\operatorname {supportVertices}(G) = \iota (\operatorname {supp}(L))\). Since \(\iota \) is injective (by the structure definition), and the domain is \(\operatorname {supp}(L)\), we have:
The equality follows by applying Finset.card_image_of_injective with the injectivity of the support embedding, then simplifying with the cardinality of the universal finset over the subtype.
For a gauging graph \(G\), the number of vertices is at least the support size:
Let \(G\) be a gauging graph. We have that \(\operatorname {supportVertices}(G) \subseteq V\) (as a subset of the universal finset). By Theorem 149, \(|\operatorname {supportVertices}(G)| = \operatorname {supportSize}(G)\). Then:
where the inequality follows from the fact that the cardinality of a subset is at most the cardinality of the superset.
For a gauging graph \(G\), the vertices partition into support vertices and dummy vertices:
By extensionality, we show that the union of support vertices and dummy vertices equals the universal set: for any vertex \(v\), either \(v \in \operatorname {supportVertices}(G)\) or \(v \in V \setminus \operatorname {supportVertices}(G)\), which holds by logic (specifically, the law of excluded middle). The sets are disjoint by definition of set difference (Finset.disjoint_sdiff). Therefore:
where the last equality follows from the cardinality of disjoint unions.
For a gauging graph \(G\), the cycle rank can be expressed as:
By the vertex partition theorem (Theorem 151), \(|V| = |\operatorname {supportVertices}(G)| + |\operatorname {dummyVertices}(G)|\). By Theorem 149, \(|\operatorname {supportVertices}(G)| = |\operatorname {supp}(L)|\). Substituting into the cycle rank definition:
This follows by integer arithmetic (omega).
1.2.3 Tree Case (Cycle Rank 0)
A gauging graph \(G\) is a tree if it has cycle rank 0:
For a gauging graph \(G\) that is a tree, the number of edges equals the number of vertices minus 1:
Assume \(G\) is a tree, so \(\operatorname {cycleRank}(G) = 0\). By definition of cycle rank:
Rearranging by integer arithmetic (omega), we get \(|E| = |V| - 1\).
1.2.4 Minimal Gauging Graph (No Dummy Vertices)
A gauging graph \(G\) is minimal if it has no dummy vertices:
For a minimal gauging graph \(G\), the vertex count equals the support size:
By Theorem 151, \(|V| = |\operatorname {supportVertices}(G)| + |\operatorname {dummyVertices}(G)|\). By Theorem 149, \(|\operatorname {supportVertices}(G)| = \operatorname {supportSize}(G)\). Since \(G\) is minimal, \(|\operatorname {dummyVertices}(G)| = 0\). Therefore \(|V| = \operatorname {supportSize}(G)\) by integer arithmetic (omega).
For a minimal tree gauging graph \(G\), the number of edges equals the support size minus 1:
1.2.5 Helper Lemmas
For a gauging graph \(G\), the number of auxiliary qubits equals the number of edges: \(|E| = |E|\).
This holds by reflexivity.
For a gauging graph \(G\) and distinct support elements \(v \neq w\), their images under the support embedding are distinct:
Assume \(v \neq w\). Suppose for contradiction that \(\iota (v) = \iota (w)\). By injectivity of \(\iota \) (from the gauging graph structure), we would have \(v = w\), contradicting \(v \neq w\). Therefore \(\iota (v) \neq \iota (w)\).
A gauging graph \(G\) with support size 1 and no dummy vertices has exactly one vertex:
By Theorem 156, \(|V| = \operatorname {supportSize}(G) = 1\) by integer arithmetic (omega).
For a gauging graph \(G\):
This holds by reflexivity (definition of dummy vertices).
For a gauging graph \(G\) and any vertex \(v\):
By definition of dummy vertices, \(\operatorname {dummyVertices}(G) = V \setminus \operatorname {supportVertices}(G)\). For any \(v \in V\), either \(v \in \operatorname {supportVertices}(G)\) or \(v \notin \operatorname {supportVertices}(G)\). In the latter case, \(v \in V \setminus \operatorname {supportVertices}(G) = \operatorname {dummyVertices}(G)\). This follows by the law of excluded middle (tauto).
For a gauging graph \(G\), the support vertices and dummy vertices are disjoint:
By definition, \(\operatorname {dummyVertices}(G) = V \setminus \operatorname {supportVertices}(G)\). The disjointness follows from Finset.disjoint_sdiff: any set is disjoint from its complement.
For a minimal tree gauging graph \(G\):
This follows directly from the hypothesis that \(G\) is a tree, which by definition means \(\operatorname {cycleRank}(G) = 0\).
1.3 Chain Spaces and Boundary Maps
Let \(G = (V, E)\) be a finite connected graph and let \(\mathcal{C}\) be a chosen collection of generating cycles for \(G\).
We define the following \(\mathbb {Z}_2\)-vector spaces and linear maps:
Chain spaces:
\(C_0(G; \mathbb {Z}_2) = \mathbb {Z}_2^V\) is the space of 0-chains (formal sums of vertices)
\(C_1(G; \mathbb {Z}_2) = \mathbb {Z}_2^E\) is the space of 1-chains (formal sums of edges)
\(C_2(G; \mathbb {Z}_2) = \mathbb {Z}_2^{\mathcal{C}}\) is the space of 2-chains (formal sums of cycles)
Boundary map \(\partial _1: C_1(G; \mathbb {Z}_2) \to C_0(G; \mathbb {Z}_2)\) is the \(\mathbb {Z}_2\)-linear map defined on basis elements by \(\partial _1(e) = v + v'\) where \(e = \{ v, v'\} \) is an edge with endpoints \(v, v'\).
Second boundary map \(\partial _2: C_2(G; \mathbb {Z}_2) \to C_1(G; \mathbb {Z}_2)\) is defined by \(\partial _2(c) = \sum _{e \in c} e\) for a cycle \(c\) viewed as a set of edges.
Coboundary maps are the transposes: \(\delta _0 = \partial _1^T: C_0(G; \mathbb {Z}_2) \to C_1(G; \mathbb {Z}_2)\) and \(\delta _1 = \partial _2^T: C_1(G; \mathbb {Z}_2) \to C_2(G; \mathbb {Z}_2)\).
Key identity: \(\partial _1 \circ \partial _2 = 0\), i.e., the boundary of a cycle is zero.
A set of edges \(S \subseteq E\) is a valid cycle if every vertex has even degree in \(S\), i.e., for all \(v \in V\):
This is the defining property that ensures \(\partial _1(\text{cycle}) = 0\).
A graph chain configuration bundles together:
A finite vertex type \(V\) with decidable equality
A finite edge type \(E\) with decidable equality
A finite cycle index type \(\mathcal{C}\) with decidable equality
A function \(\text{endpoints}: E \to V \times V\) assigning each edge its two endpoints
A proof that endpoints are distinct: for all \(e \in E\), \((\text{endpoints}(e))_1 \neq (\text{endpoints}(e))_2\)
A function \(\text{cycleEdges}: \mathcal{C} \to \mathcal{P}(E)\) assigning each cycle index its edge set
A proof that all cycles are valid: for all \(c \in \mathcal{C}\), the edge set \(\text{cycleEdges}(c)\) is a valid cycle
The 0-chain space \(C_0(G; \mathbb {Z}_2) = \mathbb {Z}_2^V\) is the space of functions \(V \to \mathbb {Z}_2\), representing formal sums of vertices.
The 1-chain space \(C_1(G; \mathbb {Z}_2) = \mathbb {Z}_2^E\) is the space of functions \(E \to \mathbb {Z}_2\), representing formal sums of edges.
The 2-chain space \(C_2(G; \mathbb {Z}_2) = \mathbb {Z}_2^{\mathcal{C}}\) is the space of functions \(\mathcal{C} \to \mathbb {Z}_2\), representing formal sums of cycles.
Given a subset \(S \subseteq V\), we define the corresponding 0-chain \(\chi _S \in C_0(G; \mathbb {Z}_2)\) by the characteristic function:
This identifies a subset with the formal sum \(\sum _{v \in S} v\).
Given a subset \(S \subseteq E\), we define the corresponding 1-chain \(\chi _S \in C_1(G; \mathbb {Z}_2)\) by the characteristic function:
For a vertex \(v \in V\), the single vertex chain is the 0-chain:
For an edge \(e \in E\), the single edge chain is the 1-chain:
For a cycle \(c \in \mathcal{C}\), the single cycle chain is the 2-chain:
For an edge \(e\) with endpoints \(v\) and \(v'\), the boundary \(\partial _1(e) \in C_0(G; \mathbb {Z}_2)\) is defined by:
The first boundary map \(\partial _1: C_1(G; \mathbb {Z}_2) \to C_0(G; \mathbb {Z}_2)\) is the \(\mathbb {Z}_2\)-linear map defined by:
for a 1-chain \(\alpha \).
For a cycle \(c\), the boundary \(\partial _2(c) \in C_1(G; \mathbb {Z}_2)\) is the characteristic function of the edge set:
The second boundary map \(\partial _2: C_2(G; \mathbb {Z}_2) \to C_1(G; \mathbb {Z}_2)\) is the \(\mathbb {Z}_2\)-linear map defined by:
for a 2-chain \(\beta \).
A set of edges \(S \subseteq E\) is a valid cycle if the boundary (sum of vertices with odd degree) is zero. Equivalently, every vertex is incident to an even number of edges in \(S\):
The composition of boundary maps is zero: \(\partial _1 \circ \partial _2 = 0\).
We apply linear map extensionality: it suffices to show that for any 2-chain \(\gamma \) and vertex \(v\), we have \((\partial _1 \circ \partial _2)(\gamma )(v) = 0\).
By definition of the boundary maps, we need to show:
By swapping the order of summation, this equals:
We show the sum is zero by proving each inner term equals zero. For each cycle \(c\):
If \(\gamma (c) = 0\), the inner sum is trivially zero by multiplication.
If \(\gamma (c) \neq 0\), we use the validity of cycles. By the cycles_valid field of the graph chain configuration, every cycle has the property that each vertex has even degree.
For the case \(\gamma (c) \neq 0\), we simplify the inner sum. The expression:
factors as \(\gamma (c)\) times the cardinality (in \(\mathbb {Z}_2\)) of the set:
By the cycle validity condition, this cardinality is even. Since even numbers map to \(0\) in \(\mathbb {Z}_2\), the product \(\gamma (c) \cdot 0 = 0\).
Therefore, the entire sum equals zero, establishing \(\partial _1 \circ \partial _2 = 0\).
The chain pairing (inner product) for chains over a finite type \(X\) is defined as:
This is the standard inner product on \(\mathbb {Z}_2^n\).
The first coboundary map \(\delta _0 = \partial _1^T: C_0(G; \mathbb {Z}_2) \to C_1(G; \mathbb {Z}_2)\) is the \(\mathbb {Z}_2\)-linear map defined by:
where \(e = \{ v, v'\} \) is an edge with endpoints \(v\) and \(v'\).
Equivalently, \(\delta _0(v)\) equals the sum of all edges incident to \(v\).
The second coboundary map \(\delta _1 = \partial _2^T: C_1(G; \mathbb {Z}_2) \to C_2(G; \mathbb {Z}_2)\) is the \(\mathbb {Z}_2\)-linear map defined by:
for a 1-chain \(\alpha \).
Equivalently, \(\delta _1(e)\) equals the sum of all cycles containing \(e\).
For all 0-chains \(\alpha \) and 1-chains \(\beta \):
That is, \(\delta _0\)is indeed the transpose of \(\partial _1\) with respect to the chain pairing.
By definition of the chain pairing and boundary/coboundary maps:
where for each edge \(e\), we write \(v = (\text{endpoints}(e))_1\) and \(v' = (\text{endpoints}(e))_2\).
By swapping the order of summation on the left-hand side:
For each fixed edge \(e\), we compute the inner sum over vertices. By definition of \(\partial _1(e)\), the only non-zero contributions come from \(v = (\text{endpoints}(e))_1\) and \(v = (\text{endpoints}(e))_2\). Using that endpoints are distinct (by the configuration hypothesis), we extract these two terms separately:
The remaining terms in the sum are zero since \(\partial _1(e)(v) = 0\) for all other vertices.
By ring arithmetic, this equals \(\beta (e) \cdot (\alpha (v) + \alpha (v'))\), which matches the right-hand side.
For all 1-chains \(\beta \) and 2-chains \(\gamma \):
That is, \(\delta _1\) is indeed the transpose of \(\partial _2\) with respect to the chain pairing.
By definition of the chain pairing and boundary/coboundary maps:
By swapping the order of summation on the left-hand side:
For each cycle \(c\), we transform the inner sum. By definition of \(\partial _2(c)\), the indicator function \(\partial _2(c)(e)\) equals 1 if \(e \in \text{cycleEdges}(c)\) and 0 otherwise. Thus:
Using the filter-sum identity, the sum over all \(e \in E\) with this indicator equals the sum over \(e \in \text{cycleEdges}(c)\):
This matches the right-hand side.
For a vertex \(v \in V\), the coboundary of the single vertex chain is:
That is, \(\delta _0(\delta _v)\) is the sum of all edges incident to \(v\).
By extensionality, we prove equality for each edge \(e\). By definition of \(\delta _0\):
We consider cases on whether \((\text{endpoints}(e))_1 = v\):
If \((\text{endpoints}(e))_1 = v\): Then \(\delta _v((\text{endpoints}(e))_1) = 1\). We consider whether \((\text{endpoints}(e))_2 = v\):
If \((\text{endpoints}(e))_2 = v\): This contradicts the distinctness of endpoints (from the configuration), so this case is impossible.
If \((\text{endpoints}(e))_2 \neq v\): Then \(\delta _v((\text{endpoints}(e))_2) = 0\), so the sum is \(1 + 0 = 1\). The right-hand side is also 1 since the first endpoint equals \(v\).
If \((\text{endpoints}(e))_1 \neq v\): Then \(\delta _v((\text{endpoints}(e))_1) = 0\) and the sum becomes \(0 + \delta _v((\text{endpoints}(e))_2)\). The result equals 1 if \((\text{endpoints}(e))_2 = v\) and 0 otherwise, matching the right-hand side.
For an edge \(e \in E\), the coboundary of the single edge chain is:
That is, \(\delta _1(\delta _e)\) is the sum of all cycles containing \(e\).
By extensionality, we prove equality for each cycle \(c\). By definition of \(\delta _1\):
We consider cases on whether \(e \in \text{cycleEdges}(c)\):
If \(e \in \text{cycleEdges}(c)\): Using the single-element sum identity, we extract the term for \(e\):
\[ \sum _{f \in \text{cycleEdges}(c)} \delta _e(f) = \delta _e(e) + \sum _{f \in \text{cycleEdges}(c), f \neq e} \delta _e(f) = 1 + 0 = 1 \]where the remaining sum is zero because \(\delta _e(f) = 0\) for \(f \neq e\).
If \(e \notin \text{cycleEdges}(c)\): For every \(f \in \text{cycleEdges}(c)\), we have \(f \neq e\), so \(\delta _e(f) = 0\). The sum is zero.
The zero element of \(C_0(G; \mathbb {Z}_2)\) is the constant zero function: \(0 = \lambda v. 0\).
This holds by reflexivity (definitional equality).
The zero element of \(C_1(G; \mathbb {Z}_2)\) is the constant zero function: \(0 = \lambda e. 0\).
This holds by reflexivity (definitional equality).
The zero element of \(C_2(G; \mathbb {Z}_2)\) is the constant zero function: \(0 = \lambda c. 0\).
This holds by reflexivity (definitional equality).
\(\partial _1(0) = 0\).
This follows from the fact that \(\partial _1\) is a linear map, which maps zero to zero.
\(\partial _2(0) = 0\).
This follows from the fact that \(\partial _2\) is a linear map, which maps zero to zero.
\(\delta _0(0) = 0\).
This follows from the fact that \(\delta _0\) is a linear map, which maps zero to zero.
\(\delta _1(0) = 0\).
This follows from the fact that \(\delta _1\) is a linear map, which maps zero to zero.
In \(\mathbb {Z}_2\), for all \(x\): \(x + x = 0\).
We proceed by case analysis on \(x \in \mathbb {Z}_2\). Since \(\mathbb {Z}_2 = \{ 0, 1\} \):
Case \(x = 0\): \(0 + 0 = 0\) by computation.
Case \(x = 1\): \(1 + 1 = 0\) by computation (since \(2 \equiv 0 \pmod{2}\)).
\(\chi _\emptyset = 0\) in \(C_0(G; \mathbb {Z}_2)\).
By extensionality, for all \(v \in V\): \(\chi _\emptyset (v) = 0\) since \(v \notin \emptyset \).
\(\chi _\emptyset = 0\) in \(C_1(G; \mathbb {Z}_2)\).
By extensionality, for all \(e \in E\): \(\chi _\emptyset (e) = 0\) since \(e \notin \emptyset \).
For subsets \(S, T \subseteq V\):
where \(S \triangle T\) denotes the symmetric difference.
By extensionality, we prove equality for each vertex \(v\). We consider all four cases based on membership in \(S\) and \(T\):
If \(v \in S\) and \(v \in T\): Then \(v \notin S \triangle T\), so \(\chi _{S \triangle T}(v) = 0\). Also \(\chi _S(v) + \chi _T(v) = 1 + 1 = 0\) (in \(\mathbb {Z}_2\)). By computation, these are equal.
If \(v \in S\) and \(v \notin T\): Then \(v \in S \triangle T\), so \(\chi _{S \triangle T}(v) = 1\). Also \(\chi _S(v) + \chi _T(v) = 1 + 0 = 1\).
If \(v \notin S\) and \(v \in T\): Then \(v \in S \triangle T\), so \(\chi _{S \triangle T}(v) = 1\). Also \(\chi _S(v) + \chi _T(v) = 0 + 1 = 1\).
If \(v \notin S\) and \(v \notin T\): Then \(v \notin S \triangle T\), so \(\chi _{S \triangle T}(v) = 0\). Also \(\chi _S(v) + \chi _T(v) = 0 + 0 = 0\).
For subsets \(S, T \subseteq E\):
where \(S \triangle T\) denotes the symmetric difference.
By extensionality, we prove equality for each edge \(e\). We consider all four cases based on membership in \(S\) and \(T\):
If \(e \in S\) and \(e \in T\): Then \(e \notin S \triangle T\), so \(\chi _{S \triangle T}(e) = 0\). Also \(\chi _S(e) + \chi _T(e) = 1 + 1 = 0\) (in \(\mathbb {Z}_2\)). By computation, these are equal.
If \(e \in S\) and \(e \notin T\): Then \(e \in S \triangle T\), so \(\chi _{S \triangle T}(e) = 1\). Also \(\chi _S(e) + \chi _T(e) = 1 + 0 = 1\).
If \(e \notin S\) and \(e \in T\): Then \(e \in S \triangle T\), so \(\chi _{S \triangle T}(e) = 1\). Also \(\chi _S(e) + \chi _T(e) = 0 + 1 = 1\).
If \(e \notin S\) and \(e \notin T\): Then \(e \notin S \triangle T\), so \(\chi _{S \triangle T}(e) = 0\). Also \(\chi _S(e) + \chi _T(e) = 0 + 0 = 0\).
[Exactness of Chain Complex]
Let \(G = (V, E)\) be a connected graph with a chosen generating set of cycles \(C\). The chain complex \(C_2 \xrightarrow {\partial _2} C_1 \xrightarrow {\partial _1} C_0\) satisfies the following exactness properties:
Exactness at \(C_1\): \(\ker (\partial _1) = \mathrm{im}(\partial _2)\) when \(C\) generates all cycles.
Exactness at \(C_0\) (almost): \(\mathrm{im}(\partial _1) = \{ c \in C_0 : |c| \equiv 0 \pmod{2}\} \).
Dual exactness: \(\delta _1 \circ \delta _0 = 0\), and \(\ker (\delta _0) = \mathbb {Z}_2 \cdot \mathbf{1}_V\) for connected \(G\).
The formalization proves:
One direction always holds: \(\mathrm{im} \subseteq \ker \) (composition is zero)
For connected graphs: \(\ker (\delta _0)\) consists only of \(0\) or \(\mathbf{1}_V\)
Parity constraint: \(\mathrm{im}(\partial _1)\) has even parity
The reverse directions require additional assumptions about cycle generation that are not part of the GraphChainConfig structure.
No proof needed for remarks.
For any \(\alpha \in C_0\) and any cycle \(c \in C\), we have
Let \(h_{\mathrm{valid}}\) be the validity condition for cycle \(c\), which states that \(c\) is a valid cycle. We expand the sum:
It suffices to show that for every vertex \(v\),
Let \(v\) be arbitrary. The two filter sets are disjoint because for any edge \(e\), the endpoints are distinct by the \(\mathrm{endpoints\_ distinct}\) property. The union of these sets equals the set of edges in \(\mathrm{cycleEdges}(c)\) incident to \(v\) (either as first or second endpoint).
By the valid cycle condition \(h_{\mathrm{valid}}\) applied to \(v\), this set has even cardinality. Converting to \(\mathbb {Z}_2\), we obtain \(0\).
Rewriting the original sums using these cardinality facts and the evenness condition, we get
The dual chain complex identity holds: \(\delta _1 \circ \delta _0 = 0\).
By extensionality, it suffices to show equality for arbitrary \(\alpha \in C_0\). For any cycle \(c\), we have
This follows directly from the coboundary sum swap theorem applied to \(\alpha \) and \(c\).
An element \(\gamma \in C_1\) is in \(\ker (\partial _1)\) if and only if for every vertex \(v\),
For the forward direction, assume \(\partial _1(\gamma ) = 0\). Then for any vertex \(v\), the component \((\partial _1(\gamma ))(v) = 0\). By definition of \(\partial _1\), this gives the required sum being zero.
For the reverse direction, assume the sum condition holds for all \(v\). By extensionality, \(\partial _1(\gamma ) = 0\) follows from the definition of \(\partial _1\).
An element \(\alpha \in C_0\) is in \(\ker (\delta _0)\) if and only if for every edge \(e\),
For the forward direction, assume \(\delta _0(\alpha ) = 0\). Then for any edge \(e\), the component \((\delta _0(\alpha ))(e) = 0\). By definition of \(\delta _0\), this gives \(\alpha ((\mathrm{endpoints}(e))_1) + \alpha ((\mathrm{endpoints}(e))_2) = 0\).
For the reverse direction, assume the sum condition holds for all \(e\). By extensionality, \(\delta _0(\alpha ) = 0\) follows from the definition of \(\delta _0\).
In \(\mathbb {Z}_2\), we have \(\alpha + \beta = 0\) if and only if \(\alpha = \beta \).
For the forward direction, assume \(\alpha + \beta = 0\). Adding \(\beta \) to both sides: \(\alpha + \beta + \beta = 0 + \beta \). By associativity and \(\beta + \beta = 0\) in \(\mathbb {Z}_2\), we get \(\alpha + 0 = \beta \), hence \(\alpha = \beta \).
For the reverse direction, assume \(\alpha = \beta \). Then \(\alpha + \beta = \beta + \beta = 0\) by computation in \(\mathbb {Z}_2\) (verified by case analysis on \(\beta \in \{ 0, 1\} \)).
If \(\alpha \in \ker (\delta _0)\), then for every edge \(e\),
Let \(e\) be an edge. By the characterization of \(\ker (\delta _0)\), we have \(\alpha ((\mathrm{endpoints}(e))_1) + \alpha ((\mathrm{endpoints}(e))_2) = 0\). By the \(\mathbb {Z}_2\) addition characterization, this implies \(\alpha ((\mathrm{endpoints}(e))_1) = \alpha ((\mathrm{endpoints}(e))_2)\).
The parity of a \(0\)-chain \(\alpha \in C_0\) is defined as
For any edge \(e\),
Let \(e\) be an edge with distinct endpoints \(v_1 = (\mathrm{endpoints}(e))_1\) and \(v_2 = (\mathrm{endpoints}(e))_2\). We split the sum over vertices by first extracting \(v_1\), then \(v_2\) from the remaining set.
For vertex \(v_1\): \(\partial _1^{\mathrm{single}}(e)(v_1) = 1\) by definition.
For vertex \(v_2\): Since \(v_2 \neq v_1\) (by the distinct endpoints property), we have \(\partial _1^{\mathrm{single}}(e)(v_2) = 1\) by definition.
For all other vertices \(v \notin \{ v_1, v_2\} \): \(\partial _1^{\mathrm{single}}(e)(v) = 0\) by definition.
Thus the sum equals \(1 + 1 + 0 = 0\) in \(\mathbb {Z}_2\).
For any edge \(e\),
By definition of parity, \(\mathrm{parity}(\partial _1^{\mathrm{single}}(e)) = \sum _{v \in V} \partial _1^{\mathrm{single}}(e)(v) = 0\) by the boundary single edge sum theorem.
For any \(1\)-chain \(\gamma \in C_1\),
This is part (ii) of the exactness statement: \(\mathrm{im}(\partial _1) \subseteq \{ \text{even parity chains}\} \).
We compute:
Swapping the order of summation:
By the boundary single edge sum theorem, each inner sum equals \(0\). Thus \(\gamma (e) \cdot 0 = 0\) for each \(e\), and the total sum is \(0\).
For all \(\gamma \in C_1\), we have \(\mathrm{parity}(\partial _1(\gamma )) = 0\).
This is exactly the statement of the boundary parity theorem.
The all-ones \(0\)-chain \(\mathbf{1}_V \in C_0\) is defined by \(\mathbf{1}_V(v) = 1\) for all \(v \in V\).
The zero \(0\)-chain \(\mathbf{0} \in C_0\) is defined by \(\mathbf{0}(v) = 0\) for all \(v \in V\).
The all-ones vector satisfies \(\delta _0(\mathbf{1}_V) = 0\).
By extensionality, for any edge \(e\):
This is verified by computation in \(\mathbb {Z}_2\).
The zero vector satisfies \(\delta _0(\mathbf{0}) = 0\).
By extensionality, for any edge \(e\):
Every element \(x \in \mathbb {Z}_2\) satisfies \(x = 0\) or \(x = 1\).
By case analysis on the two elements of \(\mathbb {Z}_2\).
For any \(\beta \in C_2\), we have \(\partial _1(\partial _2(\beta )) = 0\). This is one direction of exactness at \(C_1\).
By the chain complex identity \(\partial _1 \circ \partial _2 = 0\), applying both sides to \(\beta \) gives \((\partial _1 \circ \partial _2)(\beta ) = 0(\beta ) = 0\).
For any \(\alpha \in C_0\), we have \(\delta _1(\delta _0(\alpha )) = 0\). This is one direction of dual exactness at \(C_1\).
By the dual chain complex identity \(\delta _1 \circ \delta _0 = 0\), applying both sides to \(\alpha \) gives \((\delta _1 \circ \delta _0)(\alpha ) = 0(\alpha ) = 0\).
Two vertices \(v, w \in V\) are adjacent, written \(v \sim w\), if there exists an edge \(e \in E\) such that either \((\mathrm{endpoints}(e))_1 = v\) and \((\mathrm{endpoints}(e))_2 = w\), or \((\mathrm{endpoints}(e))_1 = w\) and \((\mathrm{endpoints}(e))_2 = v\).
A graph is vertex-connected if for any two vertices \(v, w \in V\), there exists a sequence of adjacent vertices connecting them. Formally, the reflexive-transitive closure of the adjacency relation relates all pairs of vertices.
If \(\alpha \in \ker (\delta _0)\) and vertices \(v, w\) are adjacent, then \(\alpha (v) = \alpha (w)\).
Since \(v\) and \(w\) are adjacent, there exists an edge \(e\) connecting them. By the theorem that \(\ker (\delta _0)\) is constant on edges, we have \(\alpha ((\mathrm{endpoints}(e))_1) = \alpha ((\mathrm{endpoints}(e))_2)\).
We consider two cases based on the orientation:
If \((\mathrm{endpoints}(e))_1 = v\) and \((\mathrm{endpoints}(e))_2 = w\), then \(\alpha (v) = \alpha (w)\) directly.
If \((\mathrm{endpoints}(e))_1 = w\) and \((\mathrm{endpoints}(e))_2 = v\), then \(\alpha (w) = \alpha (v)\), hence \(\alpha (v) = \alpha (w)\) by symmetry.
For a connected graph, if \(\alpha \in \ker (\delta _0)\), then \(\alpha \) is constant on all vertices: for all \(v, w \in V\), \(\alpha (v) = \alpha (w)\).
Let \(v, w \in V\). By connectedness, there exists a sequence of adjacent vertices connecting \(v\) to \(w\). We proceed by induction on the reflexive-transitive closure.
Base case (reflexivity): \(\alpha (v) = \alpha (v)\) holds trivially.
Inductive step: Assume \(\alpha (v) = \alpha (u)\) for some \(u\), and \(u\) is adjacent to \(w\). By the theorem on adjacent vertices, \(\alpha (u) = \alpha (w)\). By transitivity, \(\alpha (v) = \alpha (w)\).
For a connected graph, if \(\alpha \in \ker (\delta _0)\), then \(\alpha = \mathbf{0}\) or \(\alpha = \mathbf{1}_V\). This is part (iii) of the exactness statement.
We consider whether \(V\) is nonempty.
Case 1: \(V\) is nonempty. Let \(v_0 \in V\). By the constancy theorem, for all \(v \in V\), we have \(\alpha (v) = \alpha (v_0)\).
By the \(\mathbb {Z}_2\) case analysis, either \(\alpha (v_0) = 0\) or \(\alpha (v_0) = 1\).
If \(\alpha (v_0) = 0\): Then \(\alpha (v) = 0\) for all \(v\), so \(\alpha = \mathbf{0}\).
If \(\alpha (v_0) = 1\): Then \(\alpha (v) = 1\) for all \(v\), so \(\alpha = \mathbf{1}_V\).
Case 2: \(V\) is empty. Then \(\alpha \) is the unique function from the empty set, which equals \(\mathbf{0}\).
The cycles \(C\) generate all cycles if every \(1\)-chain in \(\ker (\partial _1)\) is in \(\mathrm{im}(\partial _2)\). Formally, for all \(\gamma \in C_1\), if \(\partial _1(\gamma ) = 0\) then there exists \(\beta \in C_2\) such that \(\partial _2(\beta ) = \gamma \).
If cycles generate all cycles, then exactness at \(C_1\) holds: for any \(\gamma \in C_1\),
For the forward direction, assume \(\partial _1(\gamma ) = 0\). By the cycles generate hypothesis, there exists \(\beta \in C_2\) with \(\partial _2(\beta ) = \gamma \).
For the reverse direction, assume there exists \(\beta \) with \(\partial _2(\beta ) = \gamma \). Then \(\partial _1(\gamma ) = \partial _1(\partial _2(\beta )) = 0\) by the image-kernel inclusion theorem.
For any \(\beta \in C_2\), we have \(\partial _1(\partial _2(\beta )) = 0\).
This is exactly the image-kernel inclusion theorem applied to \(\beta \).
For any \(\alpha \in C_0\), we have \(\delta _1(\delta _0(\alpha )) = 0\).
This is exactly the dual image-kernel inclusion theorem applied to \(\alpha \).
For any \(\alpha , \beta \in C_0\),
We compute:
using the distributivity of sums.
\(\mathrm{parity}(\mathbf{0}) = 0\).
We have \(\mathrm{parity}(\mathbf{0}) = \sum _{v \in V} 0 = 0\).
\(\mathrm{parity}(\mathbf{1}_V) = |V| \pmod{2}\).
We have \(\mathrm{parity}(\mathbf{1}_V) = \sum _{v \in V} 1 = |V| \cdot 1 = |V|\) in \(\mathbb {Z}_2\).
\(\partial _1(\mathbf{0}) = 0\).
This follows from the linearity of \(\partial _1\): linear maps preserve zero.
\(\delta _1(\mathbf{0}) = 0\).
This follows from the linearity of \(\delta _1\): linear maps preserve zero.
For any cycle \(c \in C\), we have \(\partial _1(\partial _2^{\mathrm{single}}(c)) = 0\).
By extensionality, it suffices to show that for each vertex \(v\), the \(v\)-component is zero.
We compute:
Using the definition of \(\partial _2^{\mathrm{single}}(c)(e) = 1\) if \(e \in \mathrm{cycleEdges}(c)\) and \(0\) otherwise, and the definition of \(\partial _1^{\mathrm{single}}(e)(v) = 1\) if \(v\) is an endpoint of \(e\) and \(0\) otherwise, we get:
By the valid cycle condition for \(c\) at vertex \(v\), this cardinality is even. Hence the sum is \(0\) in \(\mathbb {Z}_2\).
For any \(\gamma _1, \gamma _2 \in C_1\),
This follows from the linearity of \(\partial _1\) (map_add).
For any \(\alpha _1, \alpha _2 \in C_0\),
This follows from the linearity of \(\delta _0\) (map_add).
1.4 Cheeger Constant
This section defines the Cheeger constant (isoperimetric number) of a finite graph, which measures how well-connected or “expanding” the graph is.
Let \(G = (V, E)\) be a finite graph and \(S \subseteq V\) a subset of vertices. An edge \(e = \{ v, w\} \in E\) has exactly one endpoint in \(S\) if either \(v \in S\) and \(w \notin S\), or \(v \notin S\) and \(w \in S\).
The edge boundary of a subset \(S \subseteq V\) is:
the set of edges with exactly one endpoint in \(S\).
The edge boundary cardinality of a subset \(S \subseteq V\) is \(|\delta (S)|\), the number of edges in the boundary of \(S\).
The expansion ratio of a nonempty subset \(S \subseteq V\) is:
A subset \(S \subseteq V\) is valid for the Cheeger definition if:
\(S\) is nonempty (\(|S| {\gt} 0\)), and
\(|S| \leq |V|/2\) (equivalently, \(2|S| \leq |V|\)).
The set of all valid Cheeger subsets is the collection of all subsets \(S \subseteq V\) satisfying the valid Cheeger subset condition.
The Cheeger constant (isoperimetric number, expansion) of a graph \(G\) is:
If there are no valid subsets (i.e., \(|V| \leq 1\)), we define \(h(G) = 0\).
A graph \(G\) is a \((c, n)\)-expander if \(|V| \geq n\) and \(h(G) \geq c\).
A graph \(G\) is an expander graph if there exists a constant \(c {\gt} 0\) such that \(h(G) \geq c\).
The edge boundary of the empty set is empty: \(\delta (\emptyset ) = \emptyset \).
We unfold the definition of edge boundary and show the filter produces an empty set. Let \(e\) be any edge in \(G\). We must show that \(e\) does not have exactly one endpoint in \(\emptyset \). Pushing the negation, let \(v, w\) be arbitrary vertices. We consider two cases: if \(v \in \emptyset \), this is absurd since the empty set has no members. If \(v \notin \emptyset \), then \(w \notin \emptyset \) as well, so neither disjunct of the “one endpoint” condition can hold.
The edge boundary of the full vertex set is empty: \(\delta (V) = \emptyset \).
We unfold the definition of edge boundary and show the filter produces an empty set. Let \(e\) be any edge in \(G\). We must show that \(e\) does not have exactly one endpoint in \(V\). Pushing the negation, let \(v, w\) be arbitrary vertices. We consider two cases: if \(v \in V\) (which is always true), then we must have \(w \in V\) as well. If \(v \notin V\), this contradicts that \(v\) is a member of the universe \(V\).
For any subset \(S \subseteq V\), we have \(|\delta (S)| \geq 0\).
This follows trivially since cardinality is a natural number, and all natural numbers are non-negative.
The Cheeger constant is non-negative: \(h(G) \geq 0\).
We unfold the definition of the Cheeger constant and split on whether the set of valid Cheeger subsets is nonempty. If it is nonempty, we apply the fact that an infimum over a set is bounded below by any lower bound of that set. For each subset \(S\), if \(S\) is nonempty, we unfold the expansion ratio as a quotient of two natural number casts, which is non-negative since both numerator and denominator cast to non-negative rationals. If \(S\) is empty, the value is \(0\) by definition, which is non-negative. If the set of valid subsets is empty, the Cheeger constant is defined to be \(0\), which is trivially non-negative.
For any valid Cheeger subset \(S\), we have \(|\delta (S)| \geq h(G) \cdot |S|\).
Let \(S\) be a valid Cheeger subset. Then \(S\) is nonempty by the first condition of validity. We have \(S \in \text{validCheegerSubsets}\) by the filter membership criterion. Thus the set of valid subsets is nonempty. Since \(|S| {\gt} 0\), we have \((|S| : \mathbb {Q}) {\gt} 0\).
The infimum over valid subsets is at most the expansion ratio of \(S\) by the property of infimum. The calculation proceeds as follows:
where the first inequality uses the infimum bound and non-negativity of \(|S|\), and the equality uses cancellation of \(|S|\) (valid since \(|S| \neq 0\)).
For a single vertex \(v\), the edge boundary of \(\{ v\} \) equals the incidence set of \(v\):
We prove extensionality. Let \(e\) be an edge.
(\(\Rightarrow \)) Suppose \(e \in \delta (\{ v\} )\). Then \(e\) is an edge of \(G\) and has exactly one endpoint in \(\{ v\} \). By the definition of having one endpoint, there exist \(a, b\) such that \(e = \{ a, b\} \) and either (\(a \in \{ v\} \) and \(b \notin \{ v\} \)) or (\(a \notin \{ v\} \) and \(b \in \{ v\} \)). In the first case, \(a = v\), so \(v \in e\) via the left element. In the second case, \(b = v\), so \(v \in e\) via the right element.
(\(\Leftarrow \)) Suppose \(e\) is an edge of \(G\) containing \(v\). We use the induction principle for \(\text{Sym2}\) to write \(e = \{ a, b\} \) for some \(a, b\). Since \(v \in \{ a, b\} \), either \(v = a\) or \(v = b\). If \(v = a\), we have the adjacency \(G.\text{Adj}(v, b)\), so \(b \neq v\) (by irreflexivity of adjacency). Thus \(v \in \{ v\} \) and \(b \notin \{ v\} \), giving the left disjunct. If \(v = b\), we have the adjacency \(G.\text{Adj}(a, v)\), so \(a \neq v\). Thus \(a \notin \{ v\} \) and \(v \in \{ v\} \), giving the right disjunct.
For a vertex \(v\), we have \(|\delta (\{ v\} )| = \deg (v)\).
We unfold the definition of edge boundary cardinality and rewrite using the theorem that the edge boundary of a singleton equals the incidence set. The result then follows from the fact that the cardinality of the incidence finset equals the degree.
If \(|V| \geq 2\), then \(h(G) \leq \delta (G)\), where \(\delta (G)\) is the minimum degree of \(G\).
We unfold the definition of the Cheeger constant. Since \(|V| \geq 2 {\gt} 0\), the vertex type is nonempty. Let \(v\) be a vertex achieving the minimum degree, i.e., \(\deg (v) = \delta (G)\).
The singleton \(\{ v\} \) is a valid Cheeger subset: it is nonempty (being a singleton), and \(2 \cdot 1 = 2 \leq |V|\) by assumption. Thus \(\{ v\} \in \text{validCheegerSubsets}\), so the set of valid subsets is nonempty.
The infimum over valid subsets is at most the expansion ratio of \(\{ v\} \). The calculation proceeds:
where we used that the singleton has cardinality \(1\), the edge boundary cardinality of a singleton equals the degree, and \(v\) achieves the minimum degree.
A subset \(S\) is in the set of valid Cheeger subsets if and only if \(S\) satisfies the valid Cheeger subset condition.
We unfold the definition of valid Cheeger subsets as a filter over all subsets. By simplification, membership in a filtered set over the universe is equivalent to satisfying the filter predicate.
If \(S\) is nonempty and the edge boundary \(\delta (S)\) is nonempty, then the expansion ratio is positive.
We unfold the definitions of expansion ratio and edge boundary cardinality. The expansion ratio is positive because it is a quotient of two positive quantities: the numerator \(|\delta (S)|\) is positive since the edge boundary is nonempty, and the denominator \(|S|\) is positive since \(S\) is nonempty.
If \(G\) is an expander graph, then \(h(G) {\gt} 0\).
We unfold the definition of expander graph. By assumption, there exists \(c {\gt} 0\) such that \(h(G) \geq c\). Thus \(h(G) {\gt} 0\) by transitivity: \(0 {\lt} c \leq h(G)\).
If \(G\) is a \((c, n)\)-expander with \(c {\gt} 0\), then \(G\) is an expander graph.
We unfold the definition of expander graph. The witness is \(c\) itself: we have \(c {\gt} 0\) by assumption, and \(h(G) \geq c\) from the second component of the \((c, n)\)-expander condition.
The edge boundary is symmetric under complementation: \(\delta (S) = \delta (S^c)\).
We unfold the definition of edge boundary. It suffices to show the filter predicates are equivalent. We prove extensionality on the “has one endpoint” predicate.
(\(\Rightarrow \)) Suppose \(e = \{ v, w\} \) has one endpoint in \(S\). If \(v \in S\) and \(w \notin S\), then \(v \notin S^c\) and \(w \in S^c\), giving the right disjunct for \(S^c\). If \(v \notin S\) and \(w \in S\), then \(v \in S^c\) and \(w \notin S^c\), giving the left disjunct for \(S^c\).
(\(\Leftarrow \)) Suppose \(e = \{ v, w\} \) has one endpoint in \(S^c\). If \(v \in S^c\) and \(w \notin S^c\), then \(v \notin S\) and \(w \in S\) (since \(w \notin S^c\) means \(w \in S\)), giving the right disjunct for \(S\). If \(v \notin S^c\) and \(w \in S^c\), then \(v \in S\) and \(w \notin S\), giving the left disjunct for \(S\).
1.5 Gauss’s Law Operators
Let \(C\) be an \([[n, k, d]]\) stabilizer code, \(L = \prod _{v \in L} X_v\) an \(X\)-type logical operator, and \(G = (V, E)\) a gauging graph for \(L\).
The Gauss’s law operators are the set \(\mathcal{A} = \{ A_v\} _{v \in V}\) where each \(A_v\) is defined as:
Here \(X_v\) acts on the vertex qubit (original code qubit if \(v \in L\), or auxiliary qubit if dummy), \(X_e\) acts on the auxiliary edge qubit corresponding to edge \(e\), and the product \(\prod _{e \ni v}\) is over all edges incident to vertex \(v\).
Properties:
Each \(A_v\) is Hermitian with eigenvalues \(\pm 1\).
The operators \(\{ A_v\} \) mutually commute: \([A_v, A_{v'}] = 0\) for all \(v, v' \in V\).
They satisfy: \(\prod _{v \in V} A_v = L \cdot \prod _{e \in E} X_e^2 = L\) (since \(X_e^2 = I\)).
The \(A_v\) generate an abelian group of order \(2^{|V|-1}\) (one constraint).
1.5.1 Gauss Law Operators as \(\mathbb {Z}/2\mathbb {Z}\)-valued Supports
A Gauss law operator \(A_v\) for a vertex \(v\) in a gauging graph \(G\) is represented by its \(X\)-support over \(\mathbb {Z}/2\mathbb {Z}\). The structure consists of:
The center vertex \(v\) of this operator.
A vertex support function \(\text{vertexSupport} : V \to \mathbb {Z}/2\mathbb {Z}\).
An edge support function \(\text{edgeSupport} : \text{Sym}_2(V) \to \mathbb {Z}/2\mathbb {Z}\).
Subject to the conditions:
\(\text{vertexSupport}(v) = 1\) (support is \(1\) at the center vertex).
\(\text{vertexSupport}(w) = 0\) for all \(w \neq v\) (support is \(0\) at other vertices).
\(\text{edgeSupport}(e) = 1\) if and only if \(e\) is incident to \(v\).
Since all operators are \(X\)-type, commutativity is automatic (X operators always commute with each other).
The canonical Gauss law operator \(A_v\) for vertex \(v\) is constructed as:
1.5.2 Collection of All Gauss Law Operators
The collection of all Gauss law operators \(\{ A_v\} _{v \in V}\) is defined as the function that maps each vertex \(v\) to its corresponding Gauss law operator \(A_v\).
The number of Gauss law operators equals the number of vertices: \(|\{ A_v\} | = |V|\).
This holds by reflexivity of the definition.
The vertex support of \(A_v\) is concentrated at vertex \(v\): \((A_v).\text{vertex} = v\).
This holds by reflexivity of the definition.
1.5.3 Commutativity of Gauss Law Operators
For Pauli operators, \([A, B] = 0\) if and only if \(\omega (A, B) \equiv 0 \pmod{2}\), where \(\omega \) is the symplectic form:
Since Gauss law operators are \(X\)-type (only \(X\) operators, no \(Z\)), they have \(\text{supp}_Z(A_v) = \emptyset \) for all \(v\).
Therefore for any two Gauss law operators \(A_v\) and \(A_w\):
The \(Z\)-support of a Gauss law operator is empty (\(X\)-type operators have no \(Z\) component):
The \(Z\)-support on edges is also empty for \(X\)-type operators:
The symplectic form between two Gauss law operators \(A_v\) and \(A_w\) is:
For \(X\)-type operators, \(Z_v = Z_w = \emptyset \), so this always equals \(0\).
For any vertex \(v\), the \(Z\)-support of \(A_v\) is empty: \(\text{ZSupport}(A_v) = \emptyset \).
This holds by reflexivity of the definition.
The symplectic form equals \(0\) for \(X\)-type operators: \(\omega (A_v, A_w) = 0\).
Unfolding the definitions of the symplectic form and \(Z\)-support, we have:
Property (ii): Two Gauss law operators commute: \([A_v, A_w] = 0\) for all \(v, w \in V\).
This is proven via the symplectic form: \([A_v, A_w] = 0\) if and only if \(\omega (A_v, A_w) \equiv 0 \pmod{2}\). Since both operators are \(X\)-type (no \(Z\)-support), the symplectic form is \(0\).
By the theorem that the symplectic form equals zero, we have \(\omega (A_v, A_w) = 0\), and thus \(\omega (A_v, A_w) \mod 2 = 0\).
1.5.4 Product Constraint
Each edge \(\{ a, b\} \in E\) is incident to exactly vertices \(a\) and \(b\). Therefore, summing over all \(v\), each edge appears exactly twice.
For any edge \(e \in E\), there exist \(a, b \in V\) with \(a \neq b\) such that \(e = \{ a, b\} \) and for all \(v \in V\):
Let \(e \in E\) be an edge. We revert the hypothesis and apply \(\text{Sym2.ind}\) to decompose \(e\) into a pair \((a, b)\). From the edge set membership, we have \(G.\text{Adj}(a, b)\), which implies \(a \neq b\). We take \(a\), \(b\), the proof of \(a \neq b\), and reflexivity for \(e = \{ a, b\} \).
For the incidence characterization, we show both directions:
(\(\Rightarrow \)): If \(e \in \text{incidenceSet}(v)\), then by the definition of incidence set, \(v \in \{ a, b\} \), so \(v = a\) or \(v = b\).
(\(\Leftarrow \)): If \(v = a\) or \(v = b\), we show \(\{ a, b\} \in \text{incidenceSet}(v)\) by constructing the membership proof from \(G.\text{Adj}(a, b)\).
The product of all \(A_v\) operators (as \(\mathbb {Z}/2\mathbb {Z}\) support sums) on vertices is:
Each vertex \(v\) contributes \(1\) to position \(v\), so the sum equals all \(1\)s on \(V\).
Each vertex appears in exactly one \(A_w\) (namely \(A_v\) itself): \(\text{productVertexSupport}(v) = 1\).
Unfolding the definitions, the sum is \(\sum _w (\text{if } w = v \text{ then } 1 \text{ else } 0)\). We establish that the filter \(\{ w \in V : v = w\} \) has cardinality \(1\) by showing it equals \(\{ v\} \). Then \(\sum _{\{ v\} } 1 = 1\) in \(\mathbb {Z}/2\mathbb {Z}\).
The product of edge supports: each edge appears twice, so sum \(\equiv 0 \pmod{2}\):
In \(\mathbb {Z}/2\mathbb {Z}\), we have \(1 + 1 = 0\).
This is verified by computation (decide tactic).
For edges in the graph, sum is \(0 \pmod{2}\) since each edge is incident to exactly \(2\) vertices.
Unfolding the definitions, we obtain the two endpoints \(a\) and \(b\) of edge \(e\) from the edge incident vertices theorem, with \(a \neq b\) and the specification that \(e\) is incident to \(v\) if and only if \(v = a\) or \(v = b\).
The sum over all vertices of \((\text{if } e \in \text{incidenceSet}(v) \text{ then } 1 \text{ else } 0)\) equals the sum over \(\{ a, b\} \) of constantly \(1\). Since \(a \neq b\), this sum is \(1 + 1 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
Property (iii) - Vertex Part: \(\text{productVertexSupport}(v) = 1\) for all \(v \in V\).
This follows directly from the theorem that product vertex support equals one.
The edge support in the product is \(0\) (edges cancel pairwise).
This follows directly from the theorem that product edge support equals zero.
The product of all \(A_v\) gives a vector that is constantly \(1\) on vertices. This is the \(X\)-type logical operator \(L = \prod _{v \in V} X_v\) (on all vertices).
By function extensionality, it suffices to show \(\text{productVertexSupport}(v) = 1\) for all \(v\). This follows from the product vertex support equals one theorem.
1.5.5 Hermitian Properties
For Pauli \(X\) operators: \(X^\dagger = X\) (self-adjoint/Hermitian) and \(X^2 = I\).
Since \(A_v\) is a product of \(X\) operators: \(A_v = X_v \cdot \prod _{e \ni v} X_e\):
\(A_v^\dagger = (\prod _{e \ni v} X_e)^\dagger \cdot X_v^\dagger = (\prod _{e \ni v} X_e) \cdot X_v = A_v\) (products of \(X\) are Hermitian)
\(A_v^2 = I\) (since \(X^2 = I\) and all \(X\) operators commute)
From \(A_v^2 = I\), if \(A_v |\psi \rangle = \lambda |\psi \rangle \), then \(|\psi \rangle = A_v^2|\psi \rangle = \lambda ^2|\psi \rangle \), so \(\lambda ^2 = 1\), meaning \(\lambda = \pm 1\).
In \(\mathbb {Z}/2\mathbb {Z}\), any element added to itself equals \(0\): \(x + x = 0\).
We case split on \(x \in \{ 0, 1\} \) and verify each case by computation: \(0 + 0 = 0\) and \(1 + 1 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
\(A_v\) squares to identity (\(X^2 = I\) for all \(X\) operators). In \(\mathbb {Z}/2\mathbb {Z}\) terms, the support XOR’d with itself gives \(0\).
For any \(w\), the vertex support satisfies \((A_v).\text{vertexSupport}(w) + (A_v).\text{vertexSupport}(w) = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), which follows from the lemma that \(x + x = 0\).
Edge support also squares to zero.
For any edge \(e\), we have \((A_v).\text{edgeSupport}(e) + (A_v).\text{edgeSupport}(e) = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), which follows from the lemma that \(x + x = 0\).
Property (i) - Hermiticity: Since \(A_v\) is a product of \(X\) operators, and \(X^\dagger = X\), we have \(A_v^\dagger = A_v\). This is modeled by the self-inverse property: \(2 \cdot \text{vertexSupport}(w) = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
Using \(\text{nsmul\_ eq\_ mul}\) and the fact that \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), we have \(2 \cdot x = 0\) for any \(x\).
Property (i) - Eigenvalues \(\pm 1\): Since \(A_v^2 = I\) (represented as \(2 \cdot \text{support} = 0\) in \(\mathbb {Z}/2\mathbb {Z}\)), any eigenvalue \(\lambda \) satisfies \(\lambda ^2 = 1\), hence \(\lambda \in \{ -1, +1\} \).
In \(\mathbb {Z}/2\mathbb {Z}\) representation: \(X^2 = I\) translates to \(x + x = 0\). In the complex Hilbert space: if \(A|\psi \rangle = \lambda |\psi \rangle \) and \(A^2 = I\), then \(\lambda ^2 = 1\).
For any \(w\), \((A_v).\text{vertexSupport}(w) + (A_v).\text{vertexSupport}(w) = 0\) follows from the lemma that \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
The operator \(A_v\) has order dividing \(2\) (\(A_v^2 = I\)).
Using \(\text{nsmul\_ eq\_ mul}\) and the fact that \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), we have \(2 \cdot \text{vertexSupport}(w) = 0\).
1.5.6 Independence and Group Order
Property (iv): The \(A_v\) generate an abelian group of order \(2^{|V|-1}\).
This is because:
There are \(|V|\) generators \(A_v\) (one for each vertex).
One constraint: \(\prod _v A_v = \) all-ones vector (reduces dimension by \(1\)).
All operators commute (abelian group).
The generator matrix: rows indexed by vertices, columns by \((V \sqcup E)\). Row \(v\) has entry \(1\) at column \(v\) and at columns for edges incident to \(v\):
The generator matrix restricted to vertex part is the identity matrix. This shows that the vertex-part alone has full rank \(|V|\):
Unfolding the definitions, we case split on whether \(v = w\):
If \(v = w\): the support at \(v\) is \(1\) by definition.
If \(v \neq w\): using \(v \neq w\) and its symmetric form \(w \neq v\), the support at \(w\) is \(0\).
The generator matrix has the identity structure on vertex coordinates.
By function extensionality, this follows from the generator vertex identity theorem.
The sum of all rows of the generator matrix equals the all-ones vector. This is THE constraint that reduces dimension from \(|V|\) to \(|V|-1\):
Unfolding the definition of the generator matrix, this is exactly the product vertex support equals one theorem.
The constraint can be written as: \(\text{row}_1 + \text{row}_2 + \cdots + \text{row}_{|V|} = \) all-ones. Rearranging: \(\text{row}_{|V|} = \text{all-ones} - \text{row}_1 - \cdots - \text{row}_{|V|-1}\). This shows one row is determined by the others (linear dependency).
There exists \(v_0 \in V\) such that for all \(w\):
We obtain a witness \(v_0\) from the nonemptiness of vertices. By the constraint sum rows theorem:
From \(x + y = 1\) in \(\mathbb {Z}/2\mathbb {Z}\), we derive \(x = 1 - y\) by algebraic manipulation.
The rank of the generator matrix (dimension of row space) equals \(|V| - 1\). This is because \(|V|\) rows with \(1\) linear dependency give rank \(|V| - 1\).
There exists \(r = |V| - 1\) such that any subset \(S\) of vertices with distinct rows satisfies \(|S| \leq |V|\).
We take \(r = |V| - 1\). For any subset \(S\) of vertices, the cardinality of \(S\) is at most the cardinality of the universe \(V\). Using the definition of \(\text{numVertices}\) and integer arithmetic, we conclude \(|S| \leq |V| - 1 + 1\).
The number of independent generators equals \(|V| - 1\).
The abelian group generated by \(\{ A_v\} \) has order \(2^{|V|-1}\). Each independent generator contributes a factor of \(2\) to the group order.
The constraint equation: the sum of all \(A_v\) (in \(\mathbb {Z}/2\mathbb {Z}\)) is the all-ones vector. This represents \(\prod _v A_v = L\) in the multiplicative Pauli group.
This follows directly from the product vertex support equals one theorem.
There is exactly one linear constraint among the \(|V|\) generators:
Unfolding the definitions and case splitting on whether \(|V| \geq 1\), this follows by integer arithmetic.
The group order is \(2^{|V|-1} = 2^{\text{(number of independent generators)}}\).
Unfolding the definitions, this holds by reflexivity.
For a graph with at least one vertex, the number of independent generators is \(|V| - 1\).
Unfolding the definition, this holds by reflexivity.
The dimension of the generated group (\(\log _2\) of order) equals \(|V| - 1\).
This holds by reflexivity of the definition.
1.5.7 Vertex Degree and Support Size
The edges incident to a vertex \(v\) in the gauging graph.
The degree of a vertex (number of incident edges).
\(A_v\) has support size \(1 + \deg (v)\).
The support size equals \(1\) plus the vertex degree.
This holds by reflexivity of the definition.
1.5.8 Helper Lemmas
\(A_v\) acts on \(v\) and all edges incident to \(v\):
Unfolding the definitions and simplifying, this follows directly.
Two different vertices give different Gauss law operators: the function \(v \mapsto A_v\) is injective.
Let \(v, w\) be vertices with \(A_v = A_w\). Taking the congruence of the vertex field, we have \((A_v).\text{vertex} = (A_w).\text{vertex}\). By the vertex support singleton theorem, this gives \(v = w\).
The edge support of \(A_v\) at an edge \(e\) is:
Unfolding the definitions and simplifying, this follows directly.
The vertex support at center is exactly \(1\): \((A_v).\text{vertexSupport}(v) = 1\).
Unfolding the definitions and simplifying, since \(v = v\), the support is \(1\).
The vertex support at non-center is exactly \(0\): for \(v \neq w\), \((A_v).\text{vertexSupport}(w) = 0\).
Unfolding the definitions and simplifying, since \(w \neq v\), the conditional is false and the support is \(0\). If the support were \(1\), we would have \(w = v\), contradicting \(v \neq w\).
Edge support is nonzero only for incident edges: if \((A_v).\text{edgeSupport}(e) \neq 0\), then \(e \in \text{incidenceSet}(v)\).
Rewriting with the edge support characterization, if the support is nonzero and \(e \notin \text{incidenceSet}(v)\), then the support would be \(0\), a contradiction.
A flux configuration for a stabilizer code \(C\) with \(X\)-type logical operator \(L\) consists of:
A gauging graph \(G = (V, E)\) for \((C, L)\)
An index type \(\mathcal{C}\) for cycles in the generating set (finite with decidable equality)
A function \(\texttt{cycleEdges} : \mathcal{C} \to \mathcal{P}(E)\) assigning to each cycle index a set of edges
A proof that each cycle only contains actual edges of the graph: for all \(c \in \mathcal{C}\) and \(e \in \texttt{cycleEdges}(c)\), we have \(e \in E\)
A proof that each cycle is valid: for all \(c \in \mathcal{C}\) and all vertices \(v \in V\), the number of edges in the cycle incident to \(v\) is even, i.e., \(|\{ e \in \texttt{cycleEdges}(c) : v \in e\} |\) is even
The validity condition ensures \(\partial _1(\text{cycle}) = 0\), capturing the closure condition for cycles.
A flux operator \(B_p\) for a flux configuration \(F\) consists of:
A cycle index \(c \in \mathcal{C}\)
An edge \(Z\)-support function \(\texttt{edgeZSupport} : E \to \mathbb {Z}/2\mathbb {Z}\)
A specification that the support matches the cycle: for all edges \(e\),
\[ \texttt{edgeZSupport}(e) = \begin{cases} 1 & \text{if } e \in \texttt{cycleEdges}(c) \\ 0 & \text{otherwise} \end{cases} \]
Since all operators are \(Z\)-type (only \(Z\) operators, no \(X\)), they automatically commute with each other.
Given a flux configuration \(F\) and cycle index \(c\), the canonical flux operator \(B_c\) is constructed with:
Cycle index: \(c\)
Edge \(Z\)-support: \(e \mapsto \begin{cases} 1 & \text{if } e \in \texttt{cycleEdges}(c) \\ 0 & \text{otherwise} \end{cases}\)
The collection of all flux operators \(\{ B_p\} _{p \in \mathcal{C}}\) is defined as the function mapping each cycle index \(c\) to its canonical flux operator \(\texttt{mkFluxOperator}(F, c)\).
The number of flux operators equals the number of cycles in the generating set:
This holds by reflexivity.
For any cycle index \(c\), the cycle index of the flux operator \((\texttt{FluxOperators}(F, c)).\texttt{cycleIdx} = c\).
This holds by reflexivity of the definition.
The \(X\)-support of a flux operator is defined as the empty set:
This reflects that flux operators are \(Z\)-type and have no \(X\) component.
For all flux operators, the \(X\)-support is empty:
This holds by reflexivity of the definition of \(\texttt{fluxOperator\_ XSupport}\).
The symplectic form between two flux operators \(B_p\) and \(B_q\) is defined as:
Since flux operators are \(Z\)-type (no \(X\) component), we have \(X_p = X_q = \emptyset \), so:
For any two flux operators \(B_p\) and \(B_q\), the symplectic form is zero:
Unfolding the definitions of \(\texttt{flux\_ symplectic\_ form}\) and \(\texttt{fluxOperator\_ XSupport}\), we see that both sets are empty, so by simplification \(|\emptyset | + |\emptyset | = 0 + 0 = 0\).
Property (ii): Any two flux operators commute. That is, for all \(p, q \in \mathcal{C}\):
Since both operators are \(Z\)-type (no \(X\)-support), the symplectic form is \(0\).
By simplification using \(\texttt{flux\_ symplectic\_ eq\_ zero}\), we have \(\omega (B_p, B_q) = 0\), and \(0 \mod 2 = 0\).
The set of edges incident to vertex \(v\) that are also in cycle \(c\) is:
The symplectic form between a Gauss law operator \(A_v\) and a flux operator \(B_p\) is:
Since \(A_v\) is \(X\)-type (so \(Z(A_v) = \emptyset \)) and \(B_p\) is \(Z\)-type (so \(X(B_p) = \emptyset \)):
The symplectic form between a Gauss law operator and a flux operator is even:
This holds because cycles have even degree at each vertex.
Unfolding the definitions of \(\texttt{gaussFlux\_ symplectic\_ form}\) and \(\texttt{incidentCycleEdges}\), the result follows directly from the cycle validity condition \(F.\texttt{cycles\_ valid}(c, v)\), which states that every vertex has even degree in each cycle.
Property (iii): Gauss law operator \(A_v\) and flux operator \(B_p\) commute:
Since \(p\) is a cycle, \(v\) appears in an even number of edges of \(p\).
Let \(h\) denote the fact that \(\omega (A_v, B_p)\) is even, obtained from \(\texttt{gaussFlux\_ symplectic\_ even}\). The result \(\omega (A_v, B_p) \mod 2 = 0\) follows directly from the characterization of even numbers in terms of modular arithmetic (\(\texttt{Nat.even\_ iff}\)).
In \(\mathbb {Z}/2\mathbb {Z}\), any element added to itself equals zero:
We proceed by case analysis on \(x\). For \(x = 0\): \(0 + 0 = 0\). For \(x = 1\): \(1 + 1 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\). Both cases are verified by computation.
Property (i) - part 1: \(B_p^2 = I\) (since \(Z^2 = I\) for all \(Z\) operators). In \(\mathbb {Z}/2\mathbb {Z}\) terms, the support XOR’d with itself gives \(0\):
Let \(e\) be an arbitrary edge. The result follows directly from the lemma \(\texttt{ZMod2\_ self\_ add\_ self'}\) applied to \(\texttt{edgeZSupport}(e)\).
Property (i) - Hermiticity: Since \(B_p\) is a product of \(Z\) operators and \(Z^\dagger = Z\), we have \(B_p^\dagger = B_p\). This is modeled by the self-inverse property:
Let \(e\) be an arbitrary edge. Using the fact that \(\texttt{nsmul\_ eq\_ mul}\) gives \(2 \cdot x = 2x\), and that \((2 : \mathbb {Z}/2\mathbb {Z}) = 0\) (verified by computation), the result follows by simplification: \(2 \cdot \texttt{edgeZSupport}(e) = 0 \cdot \texttt{edgeZSupport}(e) = 0\).
The operator \(B_p\) has order dividing \(2\) (i.e., \(B_p^2 = I\)):
Let \(e\) be an arbitrary edge. Using \(\texttt{nsmul\_ eq\_ mul}\), we have \(2 \cdot x = 2x\). Since \((2 : \mathbb {Z}/2\mathbb {Z}) = 0\) by computation, the result follows by simplification.
The cycle rank of a flux configuration \(F\) is the cycle rank of its underlying gauging graph:
This equals \(|E| - |V| + 1\) for a connected graph.
The number of edges in the gauging graph of a flux configuration:
The number of vertices in the gauging graph of a flux configuration:
The cycle rank equals \(|E| - |V| + 1\):
Unfolding the definitions of \(\texttt{cycleRank}'\), \(\texttt{fluxConfig\_ numEdges}\), \(\texttt{fluxConfig\_ numVertices}\), and \(\texttt{GaugingGraph.cycleRank}\), the equation follows by ring arithmetic.
The size of the generating set of cycles is the cardinality of the cycle index type:
A flux configuration has a proper cycle basis if the number of generators matches the cycle rank:
The \(Z\)-support of \(B_p\) is exactly the edges in cycle \(p\):
Unfolding the definitions of \(\texttt{FluxOperators}\) and \(\texttt{mkFluxOperator}\), the result follows by simplification.
Two different cycles give different flux operators (if their edge sets differ). That is, if \(\texttt{cycleEdges}(p) \neq \texttt{cycleEdges}(q)\), then:
Assume \(\texttt{edgeZSupport}\) functions are equal; we derive a contradiction. By extensionality, it suffices to show the edge sets are equal for arbitrary \(e\). Let \(h_p\) and \(h_q\) be the support characterizations for \(p\) and \(q\) respectively. From the equality assumption, we have \(h_{eq}\) stating the supports agree at \(e\).
Rewriting with \(h_p\) and \(h_q\) in \(h_{eq}\), we get:
We proceed by case analysis on whether \(e \in \texttt{cycleEdges}(p)\) and \(e \in \texttt{cycleEdges}(q)\):
If \(e \in \texttt{cycleEdges}(p)\) and \(e \in \texttt{cycleEdges}(q)\): Both directions of the iff hold trivially.
If \(e \in \texttt{cycleEdges}(p)\) and \(e \notin \texttt{cycleEdges}(q)\): The LHS is \(1\) and RHS is \(0\), so \(1 = 0\), which is absurd.
If \(e \notin \texttt{cycleEdges}(p)\) and \(e \in \texttt{cycleEdges}(q)\): The LHS is \(0\) and RHS is \(1\), so \(0 = 1\), which is absurd by symmetry.
If \(e \notin \texttt{cycleEdges}(p)\) and \(e \notin \texttt{cycleEdges}(q)\): Both directions of the iff hold since both antecedents are false.
Thus the edge sets must be equal, contradicting the hypothesis.
Convert a cycle to a \(1\)-chain (its edge set as a \(\mathbb {Z}/2\mathbb {Z}\) vector):
The \(Z\)-support of \(B_p\) equals the \(1\)-chain representation of cycle \(p\):
By extensionality for functions, we show equality at each edge \(e\). Simplifying with the definitions of \(\texttt{FluxOperators}\), \(\texttt{mkFluxOperator}\), and \(\texttt{cycleToChain1}\), both sides evaluate to the same conditional expression.
If the edge support is nonzero at edge \(e\), then \(e\) is in the cycle:
Rewriting with \(\texttt{fluxOperator\_ support\_ characterization}\) in the hypothesis, we proceed by contradiction. Assume \(e \notin \texttt{cycleEdges}(c)\). Then by simplification, the support at \(e\) is \(0\), contradicting the assumption that it is nonzero.
If an edge is in the cycle, its support is \(1\):
Rewriting with \(\texttt{fluxOperator\_ support\_ characterization}\), and simplifying with the hypothesis \(e \in \texttt{cycleEdges}(c)\), the conditional evaluates to \(1\).
If an edge is not in the cycle, its support is \(0\):
Rewriting with \(\texttt{fluxOperator\_ support\_ characterization}\), and simplifying with the hypothesis \(e \notin \texttt{cycleEdges}(c)\), the conditional evaluates to \(0\).
The symmetric difference of two cycles corresponds to the product of flux operators. In \(\mathbb {Z}/2\mathbb {Z}\): \(B_p \cdot B_q\) has \(Z\)-support equal to the symmetric difference of the supports:
Rewriting both supports using \(\texttt{fluxOperator\_ support\_ characterization}\), and noting that the symmetric difference membership condition is \((e \in p \land e \notin q) \lor (e \notin p \land e \in q)\), we proceed by case analysis on whether \(e \in \texttt{cycleEdges}(p)\) and \(e \in \texttt{cycleEdges}(q)\):
If \(e \in p\) and \(e \in q\): Both supports are \(1\), so \(1 + 1 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\). The symmetric difference condition is false, so RHS is \(0\). \(\checkmark \)
If \(e \in p\) and \(e \notin q\): Supports are \(1\) and \(0\), so sum is \(1\). Symmetric difference condition is true, so RHS is \(1\). \(\checkmark \)
If \(e \notin p\) and \(e \in q\): Supports are \(0\) and \(1\), so sum is \(1\). Symmetric difference condition is true, so RHS is \(1\). \(\checkmark \)
If \(e \notin p\) and \(e \notin q\): Both supports are \(0\), so sum is \(0\). Symmetric difference condition is false, so RHS is \(0\). \(\checkmark \)
All cases are verified by computation.
The edge count of a flux operator (i.e., the number of edges in the corresponding cycle):
The edge count is positive for nonempty cycles:
Unfolding the definition of \(\texttt{fluxOperator\_ edgeCount}\), the result follows directly from the fact that a nonempty finite set has positive cardinality (\(\texttt{Finset.card\_ pos.mpr}\)).
1.6 Deformed Operator
This section formalizes the deformed operator construction for stabilizer codes. Let \(C\) be an \([[n, k, d]]\) stabilizer code with checks \(\{ s_i\} \), let \(L = \prod _{v \in L} X_v\) be an \(X\)-type logical operator, and let \(G = (V, E)\) be a gauging graph for \(L\).
A Pauli operator \(P\) on the original code that commutes with \(L\) can be written as:
where \(|S_Z \cap L| \equiv 0 \pmod{2}\) (even overlap with \(L\) in \(Z\)-support).
The deformed operator \(\tilde{P}\) is defined as:
where \(\gamma \) is a subset of \(E\), an edge-path in \(G\) satisfying the boundary condition:
A Pauli operator \(P\) commutes with an \(X\)-type logical operator \(L\) if and only if
The even overlap condition as a \(\mathbb {Z}_2\) value is defined as:
A Pauli operator \(P\) commutes with \(L\) if and only if \(\mathrm{zSupportOverlapMod2}(P, L) = 0\).
We unfold the definitions. For the forward direction, assume \(|S_Z(P) \cap \mathrm{support}(L)| \mod 2 = 0\). Then the cardinality is even, so its cast to \(\mathbb {Z}_2\) is zero by the property that even naturals cast to zero in \(\mathbb {Z}_2\).
For the reverse direction, assume the \(\mathbb {Z}_2\) value is \(0\). By the characterization of when a natural number casts to zero in \(\mathbb {Z}_2\), we have that \(2\) divides the cardinality, so the modular condition holds.
A deform configuration for a stabilizer code \(C\) and \(X\)-type logical \(L\) consists of:
A flux configuration \(\mathrm{fluxCfg}\) (gauging graph plus cycle basis),
An embedding \(\mathrm{qubitToVertex} : \mathrm{Fin}(n) \to V\) of original qubits into graph vertices,
A proof that the embedding is injective,
Consistency: for qubits in \(L.\mathrm{support}\), the embedding agrees with the support embedding of the gauging graph.
The gauging graph associated with a deform configuration \(D\).
The vertex type of a deform configuration.
The edge type of a deform configuration (edges as \(\mathrm{Sym}_2(V)\)).
An edge-path in the gauging graph is a finite subset of edges, i.e., a \(\mathrm{Finset}(\mathrm{Sym}_2(V))\).
The boundary of an edge-path \(\gamma \) at vertex \(w\) counts the number of edges incident to \(w\) modulo 2:
The target boundary from a Pauli operator \(P\)’s \(Z\)-support intersected with vertices is:
An edge-path \(\gamma \) satisfies the boundary condition for Pauli \(P\) if:
This formalizes \(\partial _1(\gamma ) = S_Z(P) \cap V\).
A deformed operator \(\tilde{P}\) consists of:
An original Pauli operator \(P\) (including phase \(i^{\sigma }\)),
A proof that \(P\) commutes with the logical operator \(L\),
An edge-path \(\gamma \) that is a subset of \(E\),
A proof that \(\gamma \) consists of actual edges of the graph,
The boundary condition: \(\partial _1(\gamma ) = S_Z(P) \cap V\).
The deformed operator acts as \(\tilde{P} = P \cdot \prod _{e \in \gamma } Z_e\) on the extended system.
The \(Z\)-support of a deformed operator on edge qubits (as a \(\mathbb {Z}_2\) function):
The number of edges in the edge-path: \(|\gamma |\).
The original \(X\)-support preserved from \(P\).
The original \(Z\)-support preserved from \(P\).
The phase factor \(\sigma \) in \(i^{\sigma }\) from the original Pauli operator.
The target set of vertices in the image of \(S_Z(P)\) under the qubit-to-vertex embedding:
The cardinality of the target vertex set is bounded by the \(Z\)-support cardinality:
We unfold the definition of target vertex set. The result follows from the fact that the cardinality of an image is at most the cardinality of the preimage.
If \(P\) commutes with \(L\), then \(|S_Z(P) \cap \mathrm{support}(L)|\) is even.
We unfold the definition of commutation. The condition states that \(|S_Z(P) \cap \mathrm{support}(L)| \mod 2 = 0\), which is exactly the definition of evenness via the mod-2 characterization.
If \(P\) has empty \(Z\)-support, then the target boundary is zero everywhere:
By simplification: since \(S_Z(P) = \emptyset \), the existential condition \(\exists v \in S_Z(P), \mathrm{qubitToVertex}(v) = w\) is vacuously false (nothing is in the empty set), so the target boundary evaluates to \(0\).
The empty path has zero boundary at every vertex:
By simplification: filtering the empty set yields the empty set, which has cardinality \(0\), and casting \(0\) to \(\mathbb {Z}_2\) gives \(0\).
If \(P\) has empty \(Z\)-support and commutes with \(L\), then there exists an edge-path satisfying the boundary condition (namely, the empty path).
We use the empty edge-path \(\gamma = \emptyset \). The validity condition is vacuously satisfied (no edges to check). For the boundary condition, at each vertex \(w\), we have \(\partial (\emptyset )(w) = 0\) by the empty boundary lemma, and \(\mathrm{targetBoundary}(P)(w) = 0\) by the empty \(Z\)-support lemma.
The symmetric difference of two edge paths:
The boundary of the symmetric difference is the sum of boundaries:
We unfold the definitions. First, we establish that filtering over the symmetric difference equals the symmetric difference of filters. Let \(F_i = \{ e \in \gamma _i : w \in e\} \) for \(i = 1, 2\). Then the filter over \(\gamma _1 \oplus \gamma _2\) equals \(F_1 \oplus F_2\).
For the cardinality, we use the fact that for disjoint sets \(A \setminus B\) and \(B \setminus A\), we have \(|A \oplus B| = |A \setminus B| + |B \setminus A| = (|A| - |A \cap B|) + (|B| - |A \cap B|)\). In \(\mathbb {Z}_2\), subtracting \(2|A \cap B|\) gives zero, so \(|A \oplus B| = |A| + |B|\) in \(\mathbb {Z}_2\).
The result follows from the symmetric difference cardinality formula.
If two edge-paths satisfy the same boundary condition, their difference has zero boundary at every vertex:
Let \(w\) be an arbitrary vertex. By the symmetric difference boundary theorem, \(\partial (\gamma _1 \oplus \gamma _2)(w) = \partial (\gamma _1)(w) + \partial (\gamma _2)(w)\). Since both paths satisfy the boundary condition for the same operator \(P\), we have \(\partial (\gamma _1)(w) = \mathrm{targetBoundary}(P)(w) = \partial (\gamma _2)(w)\). In \(\mathbb {Z}_2\), \(x + x = 0\) for any \(x\), so the result is \(0\).
The symmetric difference of two paths with the same boundary is a cycle (has zero boundary as a function).
By function extensionality, we apply the boundary difference is cycle theorem at each vertex.
A path is a cycle if it has zero boundary at every vertex:
The difference of two valid paths for the same operator is a cycle.
This follows directly from the boundary difference is cycle theorem.
The cycle basis generates all cycles if every cycle \(\gamma \) can be written as a \(\mathbb {Z}_2\)-linear combination of basis cycles:
where \(a_c \in \mathbb {Z}_2\).
Uniqueness Theorem: When the cycle basis generates all cycles, the difference of two valid edge-paths for the same operator is a linear combination of cycle basis elements. This means the corresponding deformed operators differ by flux operators \(B_p\).
This follows directly from the path diff is cycle theorem.
The parity of a target boundary is the sum of values over all vertices:
The boundary map surjects onto even-parity chains if for any target function with even parity, there exists an edge-path realizing it:
This property holds for connected graphs.
When the target has even parity and the boundary surjects onto even-parity chains, an edge-path exists satisfying the boundary condition.
We unfold the target boundary parity assumption, giving \(\sum _w \mathrm{targetBoundary}(P)(w) = 0\). By the surjectivity hypothesis applied to \(\mathrm{targetBoundary}(P)\), we obtain an edge-path \(\gamma \) with the desired properties.
The target boundary from \(P\) has even parity if \(\mathrm{targetBoundaryParity}(P) = 0\).
Full Existence Theorem: For any Pauli operator \(P\) that commutes with \(L\), assuming the boundary map surjects onto even-parity chains (true for connected graphs) and the target has even parity, there exists an edge-path \(\gamma \) satisfying the boundary condition.
This follows directly from the edge path exists of even parity theorem.
The deformed operator’s edge \(Z\)-support is \(1\) on path edges:
By simplification: we unfold the definition of edge \(Z\)-support and use the hypothesis \(e \in \gamma \) to evaluate the conditional to \(1\).
The deformed operator’s edge \(Z\)-support is \(0\) on non-path edges:
By simplification: we unfold the definition of edge \(Z\)-support and use the hypothesis \(e \notin \gamma \) to evaluate the conditional to \(0\).
An empty path gives zero edge support everywhere.
By function extensionality: for any edge \(e\), since the path is empty, \(e \notin \emptyset \), so the edge \(Z\)-support evaluates to \(0\).
The boundary of an empty path is zero at every vertex.
By simplification: filtering the empty set yields the empty set, with cardinality \(0\), which casts to \(0\) in \(\mathbb {Z}_2\).
An operator with empty \(Z\)-support has zero target boundary everywhere.
For any vertex \(w\), the existential condition \(\exists v \in S_Z(P), \mathrm{qubitToVertex}(v) = w\) is vacuously false since \(S_Z(P) = \emptyset \), so the target boundary is \(0\).
The identity Pauli operator can be deformed with an empty path.
The identity commutes with any \(X\)-type logical operator.
We unfold the definition. The \(Z\)-support of the identity is empty, so \(|S_Z(\mathrm{id}) \cap L.\mathrm{support}| = |\emptyset | = 0\), and \(0 \mod 2 = 0\).
An \(X\)-type operator always commutes with an \(X\)-type logical (since its \(Z\)-support is empty).
We unfold the definitions. For an \(X\)-type Pauli, \(S_Z = \emptyset \). Thus \(|S_Z \cap L.\mathrm{support}| = |\emptyset | = 0\), and \(0 \mod 2 = 0\).
An \(X\)-type operator can be deformed with an empty path.
The full deformed operator representation combining original and edge qubits, representing \(\tilde{P} = P \cdot \prod _{e \in \gamma } Z_e\):
\(X\)-support on original qubits,
\(Z\)-support on original qubits,
\(Z\)-support on edge qubits (the edge-path \(\gamma \)),
Phase factor \(i^{\sigma }\).
Convert a deformed operator to its explicit product form.
The edge \(Z\)-support of the explicit form matches the edge path.
This holds by reflexivity (definitional equality).
The phase is preserved in the explicit form.
This holds by reflexivity (definitional equality).
The \(Z\)-support difference between two deformed operators with the same original \(P\) is exactly the symmetric difference of their edge paths.
This holds by reflexivity (definitional equality).
Two deformed operators from the same original differ by a cycle (flux operator). The difference \(\gamma _1 \oplus \gamma _2\) has zero boundary, making it a cycle. Since flux operators \(B_p\) are exactly products of \(Z\) over cycles, this shows the two deformed operators differ by flux operators.
Let \(w\) be an arbitrary vertex. We have the boundary conditions \(h_1\) and \(h_2\) for paths \(\gamma _1\) and \(\gamma _2\) respectively. Since both paths belong to deformed operators with the same original operator (by hypothesis \(h_{\mathrm{same}}\)), we rewrite \(h_1\) using this equality. The result then follows from the boundary difference is cycle theorem applied to the two paths with boundary conditions for the same operator.
The boundary is additive (in \(\mathbb {Z}_2\)) for disjoint paths:
We unfold the definition of edge path boundary. First, we establish that filtering over the union equals the union of filters: an edge \(e\) is in the filtered union iff it is in one of the filtered components. By the disjointness hypothesis, the filtered sets are also disjoint. Therefore, the cardinality of the union equals the sum of cardinalities, giving the result when cast to \(\mathbb {Z}_2\).
Two deformed operators from the same original differ by edge-path symmetric difference, which has zero boundary as a function.
By function extensionality, at each vertex \(w\), we use the boundary conditions from both deformed operators. Since they share the same original operator, we rewrite using this equality and apply the boundary difference is cycle theorem.
The weight of the original operator is preserved (this is a trivial reflexivity).
This holds by reflexivity.
The commutation condition is symmetric in the overlap sense:
This follows from commutativity of intersection.
\(Z\)-type operators commute with \(X\)-type logical operators when the overlap is even:
We unfold the definitions. For a \(Z\)-type Pauli with support \(S\), we have \(S_Z = S\). The evenness hypothesis gives \(|S \cap L.\mathrm{support}| \mod 2 = 0\) via the mod-2 characterization of evenness.
The edge path boundary is linear over \(\mathbb {Z}_2\).
This follows directly from the edge path boundary symmetric difference theorem.
A single edge has boundary at exactly its endpoints:
We unfold the definition and filter the singleton set. If \(w \in e\), the filter contains exactly \(\{ e\} \), which has cardinality \(1\). If \(w \notin e\), the filter is empty, which has cardinality \(0\).
[Non-commuting Operators Cannot Be Deformed]
Let \(C\) be a stabilizer code, \(L\) an \(X\)-type logical operator, and \(G\) a gauging graph.
There is no deformed version of a Pauli operator \(P\) that does not commute with \(L\).
Reason: If \([P, L] \neq 0\), then \(|S_Z(P) \cap L| \equiv 1 \pmod{2}\) (odd overlap). For \(\tilde{P} = P \cdot \prod _{e \in \gamma } Z_e\) to commute with all Gauss’s law operators \(A_v\), we would need \([\tilde{P}, A_v] = 0\) for all \(v \in V\).
But \([\tilde{P}, A_v] = 0\) requires \(|S_Z(\tilde{P}) \cap \{ v\} | + |\{ e \in \gamma : v \in e\} | \equiv 0 \pmod{2}\).
Summing over all \(v \in L\): \(\sum _{v \in L} |S_Z(P) \cap \{ v\} | + \sum _{v \in L} |\{ e \in \gamma : v \in e\} | \equiv 0\).
The second sum equals \(2|\gamma |\) (each edge counted twice) \(\equiv 0\). So we need \(|S_Z(P) \cap L| \equiv 0\), contradicting odd overlap.
Thus operators anticommuting with \(L\) cannot be extended to the deformed code.
No proof needed for remarks.
A Pauli operator \(P\) anticommutes with an \(X\)-type logical operator \(L\) if and only if \(|S_Z(P) \cap \operatorname {support}(L)| \equiv 1 \pmod{2}\) (odd overlap).
For any Pauli operator \(P\) and \(X\)-type logical \(L\):
We unfold the definitions of anticommutation and commutation.
\((\Rightarrow )\): Assume \(|S_Z(P) \cap L.\text{support}|~ \% ~ 2 = 1\). Suppose for contradiction that \(P\) commutes with \(L\), meaning \(|S_Z(P) \cap L.\text{support}|~ \% ~ 2 = 0\). By integer arithmetic (omega), this is a contradiction.
\((\Leftarrow )\): Assume \(P\) does not commute with \(L\). Since \((S_Z(P) \cap L.\text{support}).\text{card}~ \% ~ 2 \in \{ 0, 1\} \) (by the properties of modulo 2), and it is not 0 (by assumption), it must be 1. This is precisely the anticommutation condition.
For any Pauli operator \(P\) and \(X\)-type logical \(L\):
We unfold the definitions.
\((\Rightarrow )\): Assume anticommutation holds, so \(|S_Z(P) \cap L.\text{support}|~ \% ~ 2 = 1\). Taking the \(\mathbb {Z}/2\mathbb {Z}\) value, we have \(\text{val}(|S_Z(P) \cap L.\text{support}| : \mathbb {Z}/2\mathbb {Z}) = 1\). Since \(\text{val}(1 : \mathbb {Z}/2\mathbb {Z}) = 1\), by injectivity of val, we get \(|S_Z(P) \cap L.\text{support}| = 1\) in \(\mathbb {Z}/2\mathbb {Z}\).
\((\Leftarrow )\): Assume \(|S_Z(P) \cap L.\text{support}| = 1\) in \(\mathbb {Z}/2\mathbb {Z}\). Then \(\text{val}(|S_Z(P) \cap L.\text{support}|) = 1\), and by the characterization of val_natCast, we get \(|S_Z(P) \cap L.\text{support}|~ \% ~ 2 = 1\).
The indicator function \(\text{vertexInZSupport}(P, v) : \mathbb {Z}/2\mathbb {Z}\) equals 1 if there exists a qubit \(q \in S_Z(P)\) such that \(\text{qubitToVertex}(q) = v\), and 0 otherwise.
The deformed operator \(\tilde{P}\) commutes with the Gauss law operator \(A_v\) at vertex \(v\) if and only if:
This captures the condition \(|S_Z(P) \cap \{ v\} | + |\{ e \in \gamma : v \in e\} | \equiv 0 \pmod{2}\).
For \(\tilde{P}\) to commute with all Gauss law operators, the condition \(\text{deformedCommutesWithGaussLaw}(P, \gamma , v)\) must hold for every vertex \(v\) in the graph.
For any Pauli operator \(P\) and vertex \(v\):
This holds by reflexivity of the definitions.
Main Theorem: If the target boundary has odd parity (sum equals 1), then no edge-path \(\gamma \) can satisfy the boundary condition.
Formally: Let \(P\) be a Pauli operator that anticommutes with an \(X\)-type logical \(L\). If \(\text{targetBoundaryParity}(P) = 1\) and the boundary map surjects onto even-parity chains, then there does not exist an edge-path \(\gamma \) such that all edges are valid and \(\gamma \) satisfies the boundary condition.
Suppose for contradiction that there exists such an edge-path \(\gamma \) with valid edges satisfying the boundary condition.
The key observation is that the sum of the edge-path boundary over all vertices equals 0. We compute:
To establish this, we first show that for each edge \(e \in \gamma \), the set of vertices contained in \(e\) has exactly 2 elements. Let \(e = \{ a, b\} \) be an edge. Since \(e\) is in the edge set, we have \(a \neq b\). The filter of vertices in \(e\) is precisely \(\{ a, b\} \), which has cardinality 2.
Next, we sum over edges in \(\gamma \):
In \(\mathbb {Z}/2\mathbb {Z}\), since \(2 = 0\), this sum equals 0.
By double counting, we have:
The right-hand side equals \(2|\gamma |\). Taking this in \(\mathbb {Z}/2\mathbb {Z}\), using \(2 = 0\), we get \(0\).
Now, since \(\gamma \) satisfies the boundary condition, for each vertex \(v\):
Therefore:
But by assumption, \(\text{targetBoundaryParity}(P) = 1\), which means \(\sum _{v} \text{targetBoundary}(P, v) = 1\). This contradicts the equation above, completing the proof.
A \(Z\)-type operator \(Z_S\) anticommutes with an \(X\)-type logical \(L\) if and only if \(|S \cap L.\text{support}| \equiv 1 \pmod{2}\).
This follows directly from the definitions by reflexivity. The \(Z\)-support of \(Z_S\) is precisely \(S\).
If a \(Z\)-type operator \(Z_S\) has odd overlap with \(L\) (i.e., \(|S \cap L.\text{support}| \equiv 1 \pmod{2}\)), and the target boundary has odd parity, then no valid edge-path \(\gamma \) can satisfy the boundary condition.
An operator \(P\) can be deformed (i.e., there exists a valid edge-path \(\gamma \) satisfying the boundary condition) if and only if the target boundary has even parity.
\((\Rightarrow )\): If a valid edge-path exists, we already have the even parity assumption.
\((\Leftarrow )\): If the target boundary has even parity, then by the surjectivity hypothesis (boundary surjects onto even-parity chains), there exists an edge-path \(\gamma \) with the target boundary as its boundary.
For any Pauli operator \(P\):
This holds by reflexivity of the definition.
The identity operator does not anticommute with any \(X\)-type logical operator.
By simplification, the \(Z\)-support of the identity is empty, so the intersection with \(L.\text{support}\) is empty, and its cardinality is 0. Thus \(0 \bmod 2 = 0 \neq 1\), so anticommutation does not hold. This is verified by computation (decide).
\(X\)-type operators have empty \(Z\)-support, hence they do not anticommute with \(X\)-type logicals.
By simplification, the \(Z\)-support of an \(X\)-type Pauli is empty, so the intersection with \(L.\text{support}\) is empty with cardinality 0. Since \(0 \bmod 2 = 0 \neq 1\), anticommutation does not hold. This is verified by computation (decide).
Every Pauli operator \(P\) either commutes or anticommutes with an \(X\)-type logical \(L\).
We unfold the definitions. Since \(|S_Z(P) \cap L.\text{support}| \bmod 2 {\lt} 2\), the value is either 0 (commutation) or 1 (anticommutation). By integer arithmetic (omega), one of these must hold.
Every Pauli operator \(P\) either commutes with \(L\) (and does not anticommute) or anticommutes with \(L\) (and does not commute). These are mutually exclusive.
We unfold the definitions. Since \(|S_Z(P) \cap L.\text{support}| \bmod 2 {\lt} 2\), the value is exactly one of 0 or 1. If it equals 0, then \(P\) commutes and does not anticommute. If it equals 1, then \(P\) anticommutes and does not commute. By integer arithmetic (omega), one of these cases holds.
If \(P\) anticommutes with \(L\), then \(P\) does not commute with \(L\).
By Theorem 400, anticommutation is equivalent to non-commutation. The result follows directly.
If \(P\) does not commute with \(L\), then \(P\) anticommutes with \(L\).
By Theorem 400, anticommutation is equivalent to non-commutation. The result follows directly by rewriting.
A \(Z\)-type operator \(Z_{\{ q\} }\) with singleton support anticommutes with \(L\) if and only if \(q \in L.\text{support}\).
We simplify using the definition.
\((\Rightarrow )\): Assume anticommutation holds, so \(|\{ q\} \cap L.\text{support}| \bmod 2 = 1\). Suppose for contradiction that \(q \notin L.\text{support}\). Then \(\{ q\} \cap L.\text{support} = \emptyset \), so its cardinality is 0 and \(0 \bmod 2 = 0 \neq 1\), a contradiction.
\((\Leftarrow )\): Assume \(q \in L.\text{support}\). Then \(\{ q\} \cap L.\text{support} = \{ q\} \), which has cardinality 1, and \(1 \bmod 2 = 1\), so anticommutation holds.
If \(P\) commutes with \(L\) and \(Q\) commutes with \(L\), then \(P \cdot Q\) commutes with \(L\).
We unfold the definition of commutation. The \(Z\)-support of \(P \cdot Q\) is the symmetric difference of the \(Z\)-supports of \(P\) and \(Q\). By Lemma 99, we have:
Since \(|S_Z(P) \cap L.\text{support}| \bmod 2 = 0\) and \(|S_Z(Q) \cap L.\text{support}| \bmod 2 = 0\), by integer arithmetic (omega), the sum is also 0 modulo 2.
1.7 Deformed Check (Definition 9)
Let \(C\) be an \([[n, k, d]]\) stabilizer code with checks \(\{ s_j\} \), let \(L\) be an \(X\)-type logical operator with support \(L\), and let \(G = (V, E)\) be a gauging graph.
For each check \(s_j = i^{\sigma _j} \prod _{v \in S_{X,j}} X_v \prod _{v \in S_{Z,j}} Z_v\) of the original code:
The deformed check \(\tilde{s}_j\) is defined as:
where \(\gamma _j\) is a subset of \(E\) satisfying \(\partial _1(\gamma _j) = S_{Z,j} \cap V\).
Two cases:
If \(S_{Z,j} \cap L = \emptyset \) (check has no \(Z\)-support on \(L\)), then \(\gamma _j = \emptyset \) and \(\tilde{s}_j = s_j\). We denote the set of such checks as \(\mathcal{C}\).
If \(S_{Z,j} \cap L \neq \emptyset \) (check has \(Z\)-support on \(L\)), then \(\gamma _j \neq \emptyset \) is a nontrivial path. We denote the set of such checks as \(\mathcal{S}\).
1.7.1 Check Type Classification
For a stabilizer check \(s\) and an \(X\)-type logical operator \(L\), the \(Z\)-support intersection with the logical support is defined as:
A stabilizer check \(s\) is Type C with respect to logical operator \(L\) if the \(Z\)-support intersection with the logical support is empty:
A stabilizer check \(s\) is Type S with respect to logical operator \(L\) if the \(Z\)-support intersection with the logical support is nonempty:
For any stabilizer check \(s\) and logical operator \(L\), either \(s\) is Type C or \(s\) is Type S:
We unfold the definitions of isTypeC, isTypeS, and checkZSupportOnLogical. We then consider two cases based on whether the intersection \(s.\mathrm{supportZ} \cap L.\mathrm{support}\) is empty. If the intersection is empty, we have isTypeC by definition. Otherwise, the set is nonempty (by the contrapositive of emptiness), giving us isTypeS.
A check is Type C if and only if it is not Type S:
We unfold the definitions and rewrite using the equivalence that a finset is nonempty iff it is not empty. The result follows by the standard propositional equivalence between \(P\) and \(\neg \neg P\) pushed through negation.
1.7.2 Deformed Check Definition
For a stabilizer check \(s\) and deformation configuration \(D\), the \(Z\)-support on vertices is the image of the \(Z\)-support under the qubit-to-vertex embedding:
The target boundary for a check \(s\) at vertex \(w\) is:
An edge path \(\gamma \) satisfies the check boundary condition for check \(s\) if:
where \(\partial _1(\gamma )(w)\) is the edge path boundary at vertex \(w\).
A deformed check \(\tilde{s}_j\) consists of:
The check index \(j \in \{ 0, \ldots , n-k-1\} \)
The original check \(s_j\) from the stabilizer code
Proof that \(s_j\) equals the check at index \(j\): \(s_j = C.\mathrm{checks}(j)\)
An edge path \(\gamma _j \subseteq E\)
Proof that all edges in \(\gamma _j\) are valid graph edges
The boundary condition: \(\partial _1(\gamma _j) = S_{Z,j} \cap V\)
The deformed check acts as \(\tilde{s}_j = s_j \cdot \prod _{e \in \gamma _j} Z_e\).
The edge \(Z\)-support of a deformed check \(\tilde{s}\) is:
The number of edges in a deformed check’s edge path is \(|\gamma _j|\).
The original \(X\)-support of a deformed check is the \(X\)-support of the original check.
The original \(Z\)-support of a deformed check is the \(Z\)-support of the original check.
The phase factor of a deformed check is the phase of the original check.
1.7.3 Type C Checks (Unchanged)
A check \(s\) has no \(Z\)-support on vertices if:
This is a stronger condition than isTypeC.
If a check has no \(Z\)-support on vertices, then the target boundary is zero at all vertices:
We unfold the definitions of checkTargetBoundary and hasNoZSupportOnVertices. Since the \(Z\)-support on vertices is empty, no vertex \(w\) is a member of this set, so the conditional evaluates to \(0\) for all \(w\).
For a check \(j\) with no \(Z\)-support on vertices, we construct a deformed check with empty edge path:
Check index: \(j\)
Original check: \(C.\mathrm{checks}(j)\)
Edge path: \(\gamma _j = \emptyset \)
Boundary condition: satisfied since both sides are zero
1.7.4 Commutativity with Gauss Law Operators
The indicator function for whether qubit \(v\) maps to vertex \(w\):
The \(Z\)-support of a check at vertex \(w\) counts qubits in the \(Z\)-support mapping to \(w\):
The edge incidence at vertex \(w\) counts edges in \(\gamma \) incident to \(w\):
If the boundary condition is satisfied, then edge incidence equals target boundary:
We unfold the definitions of satisfiesCheckBoundaryCondition and edgePathBoundary. The boundary condition states that \(\partial _1(\gamma )(w) = \mathrm{checkTargetBoundary}(s, w)\) for all \(w\). By definition, \(\partial _1(\gamma )(w)\) equals the edge incidence at vertex \(w\). The result follows directly from the boundary condition hypothesis.
The symplectic overlap between a deformed check \(\tilde{s}\) and the Gauss law operator at vertex \(v\) is:
This counts \(|S_{Z,j} \cap \{ v\} | + |\{ e \in \gamma _j : v \in e\} |\).
Every deformed check commutes with every Gauss law operator:
Therefore \([\tilde{s}_j, A_v] = 0\) for all \(j\) and \(v\).
We unfold the definition of deformedCheck_gaussLaw_overlap and edgeIncidenceAtVertex. Let hbound be the boundary condition from the deformed check. Unfolding satisfiesCheckBoundaryCondition and edgePathBoundary, we obtain that \(|\{ e \in \gamma : v \in e\} | = \mathrm{checkTargetBoundary}(s, v)\) for vertex \(v\). Substituting this into the overlap formula:
In \(\mathbb {Z}/2\mathbb {Z}\), any element added to itself equals zero. The result follows by applying ZMod2_self_add_self’.
All deformed checks commute with all Gauss law operators:
Let \(v\) be an arbitrary vertex. We apply deformedCheck_commutes_with_gaussLaw to the deformed check \(\tilde{s}\) and vertex \(v\).
1.7.5 Classification of Code Checks
The set of Type C check indices is:
These checks have \(S_{Z,j} \cap L = \emptyset \).
The set of Type S check indices is:
These checks have \(S_{Z,j} \cap L \neq \emptyset \).
The Type C and Type S checks partition all checks:
By extensionality, it suffices to show that for any \(j\), \(j \in \mathcal{C} \cup \mathcal{S}\) iff \(j\) is a valid check index. The forward direction is immediate since both sets only contain valid indices. For the reverse direction, we simplify using the definitions of typeCChecks and typeSChecks, then apply typeC_or_typeS to show that every check \(C.\mathrm{checks}(j)\) is either Type C or Type S.
The Type C and Type S checks are disjoint:
We rewrite disjointness as: for any \(j \in \mathcal{C}\) and \(m \in \mathcal{S}\), we have \(j \neq m\). Simplifying the membership conditions, we get that \(C.\mathrm{checks}(j)\) is Type C and \(C.\mathrm{checks}(m)\) is Type S. Suppose for contradiction that \(j = m\). Then \(C.\mathrm{checks}(j)\) would be both Type C and Type S. Rewriting Type C as not Type S using typeC_iff_not_typeS gives a contradiction.
1.7.6 Type S Checks Require Nontrivial Paths
A Type S deformed check is a deformed check where:
The original check is Type S: \(\mathrm{isTypeS}(s, L)\)
The edge path is nonempty: \(\gamma .\mathrm{Nonempty}\)
This captures case (ii) from the definition where checks with \(Z\)-support on \(L\) require nontrivial paths.
If a check \(s\) is Type S with respect to logical \(L\), then there exists a vertex in the logical support that is also in the \(Z\)-support:
We unfold isTypeS and checkZSupportOnLogical. Since the check is Type S, the intersection \(s.\mathrm{supportZ} \cap L.\mathrm{support}\) is nonempty. Rewriting nonemptiness in terms of non-emptiness and applying Finset.nonempty_iff_ne_empty, we obtain an element \(v\) in the intersection. Since \(v\) is in the intersection, \(v \in L.\mathrm{support}\) and \(v \in s.\mathrm{supportZ}\).
1.7.7 Deformed Checks Collection
A deformed checks collection for a code with \(n-k\) checks consists of:
A deformed check for each index \(j \in \{ 0, \ldots , n-k-1\} \)
The index matching property: the check at position \(j\) has index \(j\)
All deformed checks in a collection commute with all Gauss law operators:
This follows directly from deformedCheck_commutes_with_gaussLaw applied to each deformed check in the collection.
The number of deformed checks equals \(n - k\):
This follows from Fintype.card_fin: the cardinality of \(\mathrm{Fin}(n-k)\) equals \(n-k\).
1.7.8 Explicit Deformed Check Formula
A deformed check operator is the explicit representation \(\tilde{s}_j = s_j \cdot \prod _{e \in \gamma _j} Z_e\) consisting of:
\(X\)-support on original qubits: \(S_{X,j} \subseteq \{ 0, \ldots , n-1\} \)
\(Z\)-support on original qubits: \(S_{Z,j} \subseteq \{ 0, \ldots , n-1\} \)
\(Z\)-support on edge qubits: \(\gamma _j \subseteq E\)
Phase factor: \(i^{\sigma _j}\)
Convert a deformed check to its explicit operator representation:
Original \(X\)-support: \(s.\mathrm{supportX}\)
Original \(Z\)-support: \(s.\mathrm{supportZ}\)
Edge \(Z\)-support: \(\gamma \)
Phase: \(s.\mathrm{phase}\)
1.7.9 Helper Lemmas
For an edge \(e\) in the edge path, the edge \(Z\)-support is \(1\):
We simplify using the definition of edgeZSupport. Since \(e \in \gamma \), the conditional evaluates to \(1\).
For an edge \(e\) not in the edge path, the edge \(Z\)-support is \(0\):
We simplify using the definition of edgeZSupport. Since \(e \notin \gamma \), the conditional evaluates to \(0\).
The boundary of a deformed check’s edge path equals the target boundary:
This follows directly from the boundary condition stored in the deformed check structure.
If the target boundary is zero everywhere, then the empty path satisfies the boundary condition:
Let \(w\) be an arbitrary vertex. We simplify the edge path boundary of the empty set: filtering the empty set gives the empty set, whose cardinality is \(0\). By hypothesis, the target boundary is also \(0\) at \(w\). Thus both sides equal \(0\).
If the \(Z\)-support on vertices is empty, the target boundary is zero:
We simplify using the definition of checkTargetBoundary. Since the \(Z\)-support on vertices is empty, no vertex \(w\) is a member, so the conditional evaluates to \(0\).
A deformed check constructed via mkEmptyPathDeformedCheck has an empty edge path:
This holds by reflexivity, as the edge path is defined to be \(\emptyset \) in the construction.
The check target boundary equals the target boundary from DeformedOperator:
We unfold the definitions of checkTargetBoundary, targetBoundary, and checkZSupportOnVertices. Both definitions use the same condition: whether \(w\) is in the image of \(s.\mathrm{supportZ}\) under \(D.\mathrm{qubitToVertex}\). The result follows by simplification.
If two edge paths satisfy the same boundary condition, their symmetric difference is a cycle:
Let \(w\) be an arbitrary vertex. We apply boundary_diff_is_cycle to \(\gamma _1\), \(\gamma _2\), and \(s\). This requires showing that both paths satisfy the target boundary condition from DeformedOperator. For each path, we use the hypothesis that it satisfies the check boundary condition and rewrite using checkTargetBoundary_eq_targetBoundary to convert to the required form.
A deformed check can be converted to a deformed operator if its original check commutes with the logical:
We construct the deformed operator with:
Original: \(s\) (the original check)
Commutes with \(L\): given by hypothesis
Edge path: \(\gamma \) (the deformed check’s edge path)
Edge path valid: from the deformed check’s validity proof
Boundary condition: we convert the deformed check’s boundary condition using checkTargetBoundary_eq_targetBoundary
The result follows by reflexivity of the original and edge path fields.
A deformed code configuration for a stabilizer code \(C\) with X-type logical operator \(L\) consists of:
A deformation configuration \(\texttt{deformCfg}\)
A collection of deformed checks \(\texttt{deformedChecks}\)
The underlying gauging graph of a deformed code configuration is the gauging graph from its deformation configuration.
The flux configuration of a deformed code configuration is the flux configuration from its deformation configuration.
The number of Gauss law operators in a deformed code configuration equals \(|V|\), the number of vertices in the gauging graph.
The number of flux operators in a deformed code configuration equals \(|C|\), the size of the cycle basis.
The number of deformed checks in a deformed code configuration equals \(n - k\), where \(n\) is the number of physical qubits and \(k\) is the code dimension.
The Gauss law operator \(A_v\) has order 2 (\(A_v^2 = I\)), which implies eigenvalues \(\pm 1\). For all vertices \(w\), we have \(2 \cdot (\texttt{vertexSupport}(A_v))(w) = 0\).
This follows directly from the order-two property of Gauss law operators.
After measurement, \(A_v\) stabilizes the code space. In \(\mathbb {Z}_2\) terms, for all vertices \(w\):
This captures that \(A_v^2 = I\), meaning \(A_v\) is its own inverse, so \(A_v|\psi \rangle = |\psi \rangle \) in the \(+1\) eigenspace.
Let \(w\) be an arbitrary vertex. By the \(\mathbb {Z}_2\) self-addition property, any element added to itself equals zero. Thus \((\texttt{vertexSupport}(A_v))(w) + (\texttt{vertexSupport}(A_v))(w) = 0\).
After measurement, all Gauss law operators \(A_v\) satisfy the stabilizer condition:
Let \(v\) and \(w\) be arbitrary vertices. This follows directly from the previous theorem applied to vertex \(v\) and coordinate \(w\).
Edge qubits initialized in \(|0\rangle \) satisfy \(Z|0\rangle = |0\rangle \). In \(\mathbb {Z}_2\) terms, for any cycle \(c\) and edge \(e\):
This follows from the \(\mathbb {Z}_2\) self-addition property: any element added to itself equals zero.
For \(B_p\) to commute with \(A_v\) after initialization, the overlap must be even. Since \(p\) is a cycle, every vertex \(v\) has even degree in \(p\):
This follows from the Gauss-flux symplectic form being even.
\(B_p\) is a stabilizer because:
Edge qubits start in \(|0\rangle \), so \(Z|0\rangle = |0\rangle \) (eigenvalue \(+1\))
\(B_p = \prod _{e \in p} Z_e\) is a product of \(Z\) operators on a cycle
\(B_p\) commutes with all \(A_v\) (cycle has even degree at each vertex)
Formally:
\(B_p^2 = I\): \(\forall e: 2 \cdot (\texttt{edgeZSupport}(B_p))(e) = 0\)
\(B_p\) commutes with all \(A_v\): \(\forall v \in V: \omega _{\text{Gauss-Flux}}(v, c) \equiv 0 \pmod{2}\)
We prove both parts separately.
The first part follows from the order-two property of flux operators.
For the second part, let \(v\) be an arbitrary vertex. This follows from the Gauss-flux commutativity theorem.
The cycle condition is essential: for \(B_p\) to commute with \(A_v\), the overlap \(|\{ e \in p : v \in e\} |\) must be even for all \(v\):
This is given by the cycle validity condition in the flux configuration.
For all vertices \(v \in V\) and cycles \(c \in C\):
The symplectic form \(\omega (A_v, B_p)\) counts edges incident to \(v\) that are in cycle \(p\). Since \(p\) is a cycle, each vertex has even degree in \(p\).
This follows directly from the Gauss-flux commutativity theorem for flux configurations.
The symplectic form between Gauss law and flux operators is even:
This follows from the Gauss-flux symplectic evenness theorem.
For all vertices \(v \in V\) and deformed checks \(\tilde{s}_j\):
This uses the boundary condition \(\partial _1(\gamma _j) = S_{Z,j} \cap V\).
This follows from the theorem that deformed checks commute with Gauss law operators.
All Gauss law operators commute with all deformed checks:
Let \(v\) be an arbitrary vertex and \(j\) an arbitrary check index. This follows directly from the Gauss-check commutativity theorem.
The X-support of a deformed check on edge qubits is empty. Deformed checks only have Z-support on edges (from \(\gamma _j\)), not X-support:
The edge X-support of any deformed check is empty:
This holds by definition.
The symplectic form between a flux operator \(B_p\) and a deformed check \(\tilde{s}_j\) is:
The symplectic form between flux operators and deformed checks is zero:
Unfolding the definition of the symplectic form, by simplification using the facts that the flux operator X-support is empty and the deformed check edge X-support is empty, both terms are empty sets with cardinality zero. Thus \(0 + 0 = 0\).
Flux operators commute with deformed checks:
By simplification using the fact that the symplectic form equals zero, we have \(0 \mod 2 = 0\).
Flux operators commute with each other:
Both \(B_p\) and \(B_q\) are Z-type operators (only Z on edges, no X).
This follows from the flux operators commutativity theorem.
Gauss law operators commute with each other:
Both \(A_v\) and \(A_w\) are X-type operators (only X on vertex and incident edges, no Z).
This follows from the Gauss law commutativity theorem.
The edge symplectic form between two deformed checks \(\tilde{s}_i\) and \(\tilde{s}_j\) is:
The edge symplectic form between any two deformed checks is zero:
Unfolding the definitions, both deformed check edge X-supports are empty, so both cardinalities are zero. Thus \(0 + 0 = 0\).
The original checks of a stabilizer code commute:
This follows from the stabilizer code property that all checks commute.
The deformed checks commute:
Let \(h_i\) and \(h_j\) be the check equality conditions for the deformed checks \(\tilde{s}_i\) and \(\tilde{s}_j\), and let \(h_{\text{idx},i}\) and \(h_{\text{idx},j}\) be the index match conditions. Rewriting using these equalities, the commutativity follows from the fact that the original stabilizer code checks commute.
The number of independent Gauss law generators is \(|V| - 1\) (accounting for one linear dependency):
The Gauss law generators have exactly \(|V| - 1\) independent elements. This follows from the constraint \(\prod _v A_v = L\) (all-ones on vertices).
Formally:
The constraint: \(\forall w \in V: \sum _{v \in V} (\texttt{vertexSupport}(A_v))(w) = 1\)
This gives exactly \(|V| - 1\) independent generators
We prove both parts.
The constraint equation follows from the Gauss law constraint equation theorem.
By unfolding the definitions, the number of independent Gauss law generators equals \(|V| - 1\) by reflexivity.
For a proper cycle basis, the flux generators correspond to the cycle basis with \(|C| = |E| - |V| + 1\) (the cycle rank). The generators are \(\mathbb {Z}_2\)-linearly independent:
This follows directly from the proper cycle basis hypothesis.
The deformed checks inherit independence from the original stabilizer code. The original code has \(n - k\) independent checks:
This follows from the cardinality of finite types.
The expected cycle rank of a deformed code configuration is the cycle rank of its gauging graph.
The total number of generators (before accounting for dependencies) is:
The number of independent generators (accounting for the Gauss law constraint) is:
The number of independent Gauss law generators:
By unfolding the definitions, this holds by reflexivity.
The total generators formula:
By unfolding the definitions and simplifying, this holds.
For a proper cycle basis:
By unfolding the definitions and simplifying, this holds.
All pairs of generators commute:
Gauss-Gauss: \(\forall v, w \in V: \omega _{\text{Gauss}}(v, w) \equiv 0 \pmod{2}\)
Gauss-Flux: \(\forall v \in V, \forall c \in C: \omega _{\text{Gauss-Flux}}(v, c) \equiv 0 \pmod{2}\)
Gauss-Check: \(\forall v \in V, \forall j: \texttt{overlap}(\tilde{s}_j, v) = 0\)
Flux-Flux: \(\forall p, q \in C: \omega _{\text{Flux}}(p, q) \equiv 0 \pmod{2}\)
Flux-Check: \(\forall c \in C, \forall j: \omega (B_c, \tilde{s}_j) \equiv 0 \pmod{2}\)
Check-Check: \(\forall i, j: [\tilde{s}_i, \tilde{s}_j] = 0\)
We prove each of the six parts:
Gauss-Gauss commutativity follows from the Gauss-Gauss commutativity theorem.
For Gauss-Flux, let \(v\) be a vertex and \(c\) a cycle index. This follows from the Gauss-Flux commutativity theorem.
For Gauss-Check, let \(v\) be a vertex and \(j\) a check index. This follows from the Gauss-Check commutativity theorem.
Flux-Flux commutativity follows from the Flux-Flux commutativity theorem.
For Flux-Check, let \(c\) be a cycle index and \(j\) a check index. This follows from the Flux-Check commutativity theorem.
Check-Check commutativity follows from the deformed check commutativity theorem.
The complete generating set theorem: these operators form a generating set of the deformed code’s stabilizer group.
Given \(|V| \geq 1\) and a proper cycle basis:
All generators are stabilizers (eigenvalue \(+1\) on code space):
\(\forall v, w: 2 \cdot (\texttt{vertexSupport}(A_v))(w) = 0\)
\(\forall c, e: 2 \cdot (\texttt{edgeZSupport}(B_c))(e) = 0\)
All generators mutually commute:
Gauss-Gauss: \(\omega _{\text{Gauss}}(v, w) \equiv 0 \pmod{2}\)
Gauss-Flux: \(\omega _{\text{Gauss-Flux}}(v, c) \equiv 0 \pmod{2}\)
Flux-Flux: \(\omega _{\text{Flux}}(p, q) \equiv 0 \pmod{2}\)
Independence: correct number of generators
\(\texttt{numIndependentGenerators} = (|V| - 1) + |C| + (n - k)\)
\(|C| = \text{cycleRank}(G)\)
We prove each of the seven parts:
For Gauss law operators, let \(v\) be a vertex. This follows from the Gauss law operator order-two theorem.
For flux operators, let \(c\) be a cycle index. This follows from the flux operator order-two theorem.
Gauss-Gauss commutativity follows from the Gauss-Gauss commutativity theorem.
For Gauss-Flux, let \(v\) be a vertex and \(c\) a cycle. This follows from the Gauss-Flux commutativity theorem.
Flux-Flux commutativity follows from the Flux-Flux commutativity theorem.
The independence count follows from the total independent generators theorem applied with the hypothesis \(|V| \geq 1\).
The cycle rank equality follows from the proper cycle basis hypothesis.
Each Gauss law operator squares to identity (\(A_v^2 = I\)):
This follows from the Gauss law operator order-two theorem.
Each flux operator squares to identity (\(B_p^2 = I\)):
This follows from the flux operator order-two theorem.
The Gauss law constraint: \(\prod _v A_v\) gives all-ones on vertices:
This follows from the Gauss law constraint equation theorem.
The number of Gauss law operators equals the number of vertices:
This holds by definition.
The number of deformed checks equals \(n - k\):
This holds by definition.
The flux operators are indexed by cycle indices:
Let \(c\) be an arbitrary cycle index. This holds by reflexivity.
Each deformed check corresponds to its index:
This follows from the index match property of the deformed checks collection.
The edge path of a deformed check satisfies the boundary condition:
This follows from the boundary condition property of the deformed check.
The symplectic form between any Gauss law and flux operator is even:
Let \(v\) be a vertex and \(c\) a cycle index. This follows from the Gauss-flux symplectic evenness theorem.
Gauss law operators are X-type (no Z-support):
This follows from the Gauss law Z-support empty theorem.
Flux operators are Z-type (no X-support):
This follows from the flux operator X-support empty theorem.
[Codespace Dimension Reduction]
This remark establishes the dimension reduction formula for gauged stabilizer codes. Let \(C\) be an \([[n, k, d]]\) stabilizer code and apply the gauging procedure with graph \(G = (V, E)\) to measure logical operator \(L\).
The dimension of the code space is reduced by exactly one qubit (i.e., the deformed code encodes \(k-1\) logical qubits).
Counting argument:
New qubits added: \(|E|\) (one per edge)
New independent \(X\)-type stabilizers: \(|V| - 1\) (the \(A_v\) operators, minus one for the constraint \(\prod _v A_v = L\))
New independent \(Z\)-type stabilizers: \(|E| - |V| + 1\) (cycle rank = number of independent \(B_p\) operators)
Net change in encoded qubits:
However, this counts only the qubit/stabilizer balance for the gauging structure. The logical operator \(L\) is “consumed” by becoming the product of Gauss law operators, which reduces the original \(k\) logical qubits by \(1\).
The codespace dimension formula for a stabilizer code is:
where \(n\) is the number of physical qubits and \(r\) is the number of independent stabilizers.
For the deformed code:
Total qubits: \(n\) (original) \(+ |E|\) (new edge qubits)
Total independent stabilizers:
\((n - k)\) original deformed checks (from the original code)
\(|V| - 1\) new independent Gauss law operators \(A_v\)
\(|E| - |V| + 1\) new independent flux operators \(B_p\)
The new logical qubit count is:
So \(\Delta k = k' - k = -1\).
No proof needed for remarks.
The number of new qubits added in the gauging procedure equals the number of edges in the gauging graph:
The number of new qubits equals \(|E|\) (one per edge in the gauging graph):
This holds by definition (reflexivity).
The number of new independent \(X\)-type stabilizers is \(|V| - 1\) (Gauss law operators minus one for the constraint \(\prod _v A_v = L\)):
The number of new \(X\)-stabilizers equals \(|V| - 1\) (Gauss law operators with one constraint):
This holds by definition (reflexivity).
The constraint that all Gauss law operators multiply to give \(L\) is represented as the sum of generators giving the all-ones vector:
This follows directly from the Gauss law constraint equation applied to the gauging graph.
The number of new independent \(Z\)-type stabilizers equals the cycle rank:
For a proper cycle basis, the number of flux operators equals the cycle rank:
This follows directly from the property that the cycle basis is proper, which ensures the number of independent cycles equals the cycle rank.
The cycle rank satisfies the formula:
This holds by definition of the cycle rank.
The net change in qubits from adding edge qubits and new stabilizers:
This computes \(|E| - (|V| - 1) - (|E| - |V| + 1)\).
The net qubit-stabilizer change from gauging is \(0\). This means the gauging procedure itself is “balanced” in terms of qubits vs stabilizers:
We unfold the definitions of netQubitStabilizerChange, newQubits, and newXStabilizers. Let \(h_{\text{cycleRank}}\) denote the equality \(\text{newZStabilizers} = \text{cycleRank}\) and \(h_{\text{formula}}\) denote the cycle rank formula. We have:
Since the number of vertices is at least \(1\), casting to integers and applying linear arithmetic yields the result.
The dimension of the code space is reduced by exactly \(1\). The logical operator \(L\) becomes the product of all Gauss law operators:
Since the \(A_v\) are now stabilizers (measured with \(+1\) outcome), the logical \(L\) is no longer an independent logical operator—it has become a stabilizer. This “consumes” exactly one logical qubit, so the deformed code encodes \(k - 1\) logical qubits instead of \(k\).
Formally:
The net change from gauging balances to \(0\): \(\text{netQubitStabilizerChange}(\mathrm{cfg}) = 0\)
The constraint \(\prod _v A_v = L\) means \(L\) becomes a stabilizer
We prove both conjuncts separately using the constructor tactic. The first follows directly from the theorem netQubitStabilizerChange_eq_zero. The second follows directly from gaussLaw_constraint_gives_one.
The deformed code encodes \(k - 1\) logical qubits:
Given \(k \geq 1\) (which holds for any code with a logical operator), the change in logical qubits is \(-1\):
We unfold the definition of deformedNumLogical, giving \((k - 1) - k\). By integer arithmetic with the assumption \(k \geq 1\), this equals \(-1\).
A cycle graph configuration represents a graph \(C_n\) with \(|V| = |E|\) and cycle rank \(= 1\):
numVerts: Number of vertices in the cycle
numEdgesVal: Number of edges equals number of vertices
verts_ge_three: The cycle has at least \(3\) vertices: \(\text{numVerts} \geq 3\)
edges_eq_verts: For a cycle graph: \(|E| = |V|\)
cycleRank_eq_one: Cycle rank \(= 1\) for a single cycle: \(|E| - |V| + 1 = 1\)
For a cycle graph, the cycle rank is \(1\):
This follows directly from the cycleRank_eq_one field of the CycleGraphExample structure.
For a cycle graph, the net qubit-stabilizer change from gauging is \(0\):
Let \(h\) denote the cycle rank equation cycleRank_eq_one and \(h_e\) denote edges_eq_verts. By integer arithmetic (omega tactic), we have:
Constructs a cycle graph example with \(m\) vertices (where \(m \geq 3\)):
numVerts \(:= m\)
verts_ge_three \(:= h_m\) (the proof that \(m \geq 3\))
numEdgesVal \(:= m\)
edges_eq_verts \(:=\) reflexivity
cycleRank_eq_one: By integer arithmetic, \(m - m + 1 = 1\)
Total qubits in the deformed system:
Total independent stabilizers in the deformed system equals original deformed checks plus new Gauss law plus new flux:
The deformed code dimension formula verification. For a stabilizer code, logical qubits \(=\) physical qubits \(-\) independent stabilizers. The following hold:
\(\text{netQubitStabilizerChange}(\mathrm{cfg}) = 0\)
\(\text{newQubits}(\mathrm{cfg}) = |E|\)
\(\text{newXStabilizers}(\mathrm{cfg}) = |V| - 1\)
\(\text{newZStabilizers}(\mathrm{cfg}) = \text{cycleRank}(G)\)
We prove the four conjuncts using the refine tactic. The first follows from netQubitStabilizerChange_eq_zero. The second holds by reflexivity. The third follows by unfolding newXStabilizers and applying integer arithmetic with the assumption that the number of vertices is at least \(1\). The fourth follows from newZStabilizers_eq_cycleRank.
The cycle rank is non-negative for connected graphs. Assuming \(|E| \geq |V| - 1\) (which holds for connected graphs):
We unfold the definition of cycleRank, which gives \(|E| - |V| + 1\). By the hypothesis \(|E| \geq |V| - 1\), we have \(|E| - |V| + 1 \geq 0\). This follows by integer arithmetic.
For a tree (cycle rank \(= 0\)), we have \(|E| = |V| - 1\):
We unfold the definition of cycleRank in the hypothesis htree. This gives \(|E| - |V| + 1 = 0\). By integer arithmetic, we obtain \(|E| = |V| - 1\).
Each new stabilizer is independent (stated in terms of counts):
Gauss law: \(|V| - 1\) independent (one constraint): \(\text{numIndependentGaussLaw}(\mathrm{cfg.codeConfig}) = |V| - 1\)
Flux: cycle rank independent: \(|\text{CycleIdx}| = \text{cycleRank}(G)\)
Original checks: \(n - k\) independent (from original code): \(|\mathrm{Fin}(n - k)| = n - k\)
We prove the three conjuncts using the refine tactic. The first follows from numIndependentGaussLaw_eq. The second follows from cfg.properCycleBasis. The third follows from Fintype.card_fin.
The constraint formula: the product of all \(A_v\) equals the logical operator \(L\):
This follows directly from gaussLaw_constraint_equation applied to the gauging graph.
The deformed number of logical qubits is \(k - 1\):
This holds by definition (reflexivity).
The number of new \(X\)-stabilizers is \(|V| - 1\):
This holds by definition (reflexivity).
The number of new qubits is \(|E|\):
This holds by definition (reflexivity).
The dimension reduction is exactly \(1\) (alternative statement). Given \(k \geq 1\):
We unfold the definition of deformedNumLogical, giving \(k - (k - 1)\). By integer arithmetic with the assumption \(k \geq 1\), this equals \(1\).
[Freedom in Deformed Checks]
There is significant freedom when specifying a generating set of checks for the deformed code.
Sources of freedom:
Choice of paths \(\gamma _j\): For each deformed check \(\tilde{s}_j = s_j \prod _{e \in \gamma _j} Z_e\), any path \(\gamma _j\) satisfying \(\partial _1(\gamma _j) = S_{Z,j} \cap V\) gives a valid deformed check. Different choices \(\gamma _j\) and \(\gamma _j'\) satisfy \(\gamma _j + \gamma _j' \in \ker (\partial _1) = \mathrm{im}(\partial _2)\), so \(\tilde{s}_j' = \tilde{s}_j \cdot \prod _p B_p^{a_p}\) for some \(a_p \in \mathbb {Z}_2\).
Choice of cycle basis \(\mathcal{C}\): Different generating sets of cycles give different \(B_p\) operators, but they generate the same algebra since all cycles are \(\mathbb {Z}_2\)-linear combinations of the generators.
Optimization goal: Choose paths \(\gamma _j\) and cycle basis \(\mathcal{C}\) to minimize the weight and degree of the resulting checks:
Weight of \(\tilde{s}_j = |s_j| + |\gamma _j|\) (original weight plus path length)
Degree of edge qubit \(e\) = number of checks involving \(e\)
Conventionally, one chooses minimum weight paths for each \(\gamma _j\).
Main Structures:
AlternativePaths: Structure capturing two edge paths satisfying the same boundary condition for a check, representing valid alternative choices for \(\gamma _j\).
DeformedCheckEquivalence: Structure capturing how two deformed checks from the same original check differ by flux operators.
AlternativeCycleBases: Structure for two cycle bases of the same graph.
MinimumWeightPath: A path that is minimal among all paths satisfying the same boundary condition.
OptimalDeformedChecks: Collection of deformed checks using minimum weight paths.
No proof needed for remarks.
Given two alternative paths \(\gamma _1\) and \(\gamma _2\) satisfying the same boundary condition, their path difference is defined as the symmetric difference:
Let \(\gamma _1\) and \(\gamma _2\) be two paths satisfying the same boundary condition. Then their path difference \(\gamma _1 \triangle \gamma _2\) is a cycle, i.e., it has zero boundary at every vertex. This proves that \(\gamma _j + \gamma _j' \in \ker (\partial _1)\).
Let \(w\) be an arbitrary vertex. By the boundary additivity theorem for symmetric differences, we have:
Since both paths satisfy the same boundary condition, we have \(\partial _1(\gamma _1)(w) = \partial _1(\gamma _2)(w)\). Therefore:
in \(\mathbb {Z}_2\), since \(x + x = 0\) for any \(x \in \mathbb {Z}_2\).
The path difference of two alternative paths is a cycle (has zero boundary everywhere).
This follows directly from the theorem that the path difference has zero boundary at every vertex.
Let \(\tilde{s}_1\) and \(\tilde{s}_2\) be two deformed checks from the same original check. Then their path difference is a cycle (has zero boundary).
We rewrite using the path difference equation. Let \(w\) be an arbitrary vertex. By the boundary additivity theorem for symmetric differences:
From the boundary conditions of both checks, we have \(\partial _1(\gamma _1)(w) = t(w)\) and \(\partial _1(\gamma _2)(w) = t(w)\) where \(t\) is the target boundary determined by the same original check. Therefore:
in \(\mathbb {Z}_2\).
For two deformed checks from the same original check with path difference \(\Delta \), the Z-support difference on edges is exactly the path difference. That is, for any edge \(e\):
where \(Z_i(e)\) denotes the Z-support indicator of check \(i\) on edge \(e\).
Unfolding the definitions of edge Z-support and symmetric difference, we analyze four cases based on whether \(e\) is in \(\gamma _1\) and/or \(\gamma _2\):
If \(e \in \gamma _1\) and \(e \in \gamma _2\): Then \(Z_1(e) = 1\), \(Z_2(e) = 1\), so \(Z_1(e) + Z_2(e) = 0\). Also \(e \notin \Delta \) since it’s in both paths. This is verified by computation.
If \(e \in \gamma _1\) and \(e \notin \gamma _2\): Then \(Z_1(e) = 1\), \(Z_2(e) = 0\), so \(Z_1(e) + Z_2(e) = 1\). Also \(e \in \Delta \). Verified by computation.
If \(e \notin \gamma _1\) and \(e \in \gamma _2\): Then \(Z_1(e) = 0\), \(Z_2(e) = 1\), so \(Z_1(e) + Z_2(e) = 1\). Also \(e \in \Delta \). Verified by computation.
If \(e \notin \gamma _1\) and \(e \notin \gamma _2\): Then \(Z_1(e) = 0\), \(Z_2(e) = 0\), so \(Z_1(e) + Z_2(e) = 0\). Also \(e \notin \Delta \). Verified by computation.
A cycle \(c_1\) from flux configuration \(F_1\) is expressible in basis \(F_2\) (with the same underlying graph) if there exist coefficients \(a_{c_2} \in \mathbb {Z}_2\) for each cycle index \(c_2\) of \(F_2\) such that for every edge \(e\):
where \(\mathbf{1}_c(e) = 1\) if \(e\) is in cycle \(c\) and \(0\) otherwise.
Two cycle bases are equivalent if every cycle from one basis can be expressed as a \(\mathbb {Z}_2\)-linear combination of cycles from the other basis, and vice versa. That is, they generate the same cycle space (algebra).
The weight of a deformed check \(\tilde{s}_j = s_j \prod _{e \in \gamma _j} Z_e\) is defined as:
where \(|s_j|\) is the weight of the original check and \(|\gamma _j|\) is the number of edges in the path.
The path length of an edge path \(\gamma \) is the number of edges in the path:
For a deformed check \(\tilde{s}\), the weight of its original check equals the weight of the corresponding code check:
This follows by rewriting using the check equality condition of the deformed check structure.
The weight of a deformed check decomposes as:
where \(s\) is the original check and \(\gamma \) is the edge path.
This holds by reflexivity (definitional equality).
For two deformed checks \(\tilde{s}_1\) and \(\tilde{s}_2\) from the same original check, the weight difference equals the path length difference:
Unfolding the definition of deformed check weight and using the fact that both checks have the same original check, we have:
which follows by ring arithmetic.
The edge degree of an edge \(e\) in a collection of deformed checks is the number of deformed checks whose path contains \(e\):
The maximum edge degree of a deformed checks collection is the maximum degree over all edges. (For finite graphs, this is computable; in general it may require additional structure.)
The total weight of a deformed checks collection is the sum of all deformed check weights:
For any edge \(e\), its edge degree is bounded by the number of checks:
The edge degree counts elements of a filtered subset of check indices. The cardinality of a filtered set is at most the cardinality of the original set, which equals \(n - k\) (the number of check indices).
A minimum weight path for check index \(j\) is a path \(\gamma \) such that:
All edges in \(\gamma \) are valid graph edges.
\(\gamma \) satisfies the boundary condition for check \(j\).
For any other path \(\gamma '\) satisfying the same conditions, \(|\gamma | \leq |\gamma '|\).
An optimal deformed checks collection consists of a minimum weight path for each check index, with matching indices.
For an optimal deformed checks collection, the weight of each deformed check is minimal among all valid choices. That is, for any alternative deformed check from the same original check:
Unfolding the definitions, the minimum weight path property gives us that the path length of the optimal path is at most the path length of any alternative path satisfying the same boundary condition. Since both checks have the same original check (with the same weight), the deformed check weight, being original weight plus path length, is minimal for the optimal choice. The result follows by linear arithmetic (omega).
The total edge count of a cycle basis is the sum of edge counts over all cycles in the basis:
A cycle basis \(F\) is minimal if it is a proper cycle basis and no other proper cycle basis for the same graph has smaller total edge count.
The path freedom does not change the stabilizer group: two deformed checks from the same original check with different paths give operators that differ by products of flux operators (which are already in the stabilizer group). Specifically, the path difference is a cycle.
This follows directly from the theorem that the path difference of equivalent deformed checks is a cycle.
Different path choices give deformed checks that both commute with all Gauss law operators. That is, for two deformed checks from the same original check:
Both results follow from the general theorem that any deformed check commutes with all Gauss law operators.
The empty path has zero length:
This follows from the fact that the empty finset has cardinality zero.
Path length is always non-negative:
This follows from the fact that natural numbers are non-negative.
The weight of a deformed check is at least the weight of the original check:
Unfolding the definition of deformed check weight, we have \(\mathrm{weight}(\tilde{s}) = |s| + |\gamma |\). Since \(|\gamma | \geq 0\), we have \(|s| \leq |s| + |\gamma |\).
If an edge \(e\) is not in any deformed check’s path, then its edge degree is zero.
Unfolding the definition of edge degree, we filter the check indices by whether \(e\) is in the corresponding path. By hypothesis, \(e\) is not in any path, so the filter produces the empty set. The cardinality of the empty set is zero.
For two edge paths \(\gamma _1\) and \(\gamma _2\), an edge \(e\) is in their symmetric difference if and only if it is in exactly one of them:
By the definition of symmetric difference in finsets, \(e \in \gamma _1 \triangle \gamma _2\) if and only if \((e \in \gamma _1 \land e \notin \gamma _2) \lor (e \in \gamma _2 \land e \notin \gamma _1)\). We consider both directions:
(\(\Rightarrow \)): If \(e \in \gamma _1 \triangle \gamma _2\), then either \(e \in \gamma _1\) and \(e \notin \gamma _2\) (giving \(\mathrm{Xor}'\) left case), or \(e \in \gamma _2\) and \(e \notin \gamma _1\) (giving \(\mathrm{Xor}'\) right case).
(\(\Leftarrow \)): If \(\mathrm{Xor}'(e \in \gamma _1, e \in \gamma _2)\), then either \(e \in \gamma _1\) and \(e \notin \gamma _2\) (left case of symmetric difference), or \(e \in \gamma _2\) and \(e \notin \gamma _1\) (right case).
For a minimum weight path, the weight of the resulting deformed check equals the original check weight plus the path length:
Unfolding the definitions of deformed check weight and the conversion from minimum weight path to deformed check, the result follows by simplification.
The total weight of a deformed checks collection is at least the sum of original check weights:
We apply the sum inequality lemma: it suffices to show that for each \(j\), \(\mathrm{weight}(C.\mathrm{checks}[j]) \leq \mathrm{weight}(\tilde{s}_j)\).
For each \(j\), by the check equality and index matching conditions of the deformed checks collection, the original check weight equals \(\mathrm{weight}(C.\mathrm{checks}[j])\). By the theorem that deformed check weight is at least original weight, we get the desired inequality.
1.8 Cycle-Sparsified Graph
Let \(G = (V, E)\) be a connected graph with a generating set of cycles \(C\), and let \(c {\gt} 0\) be a constant called the cycle-degree bound.
A cycle-sparsification of \(G\) with cycle-degree \(c\) is a new graph \(\bar{\bar{G}}\) constructed as follows:
Layer structure: \(\bar{\bar{G}}\) consists of \(R + 1\) layers numbered \(0, 1, \ldots , R\). Layer 0 is a copy of \(G\). Each layer \(i {\gt} 0\) is a copy of the vertices of \(G\).
Inter-layer edges: For each vertex \(v\) in layer \(i {\lt} R\), add an edge connecting \(v\) to its copy in layer \(i+1\).
Cycle cellulation: Each cycle \(p\) from the original generating set is cellulated into triangles by adding edges. For a cycle visiting vertices \((v_1, v_2, \ldots , v_m)\) in order, add edges: \(\{ (v_1, v_{m-1}), (v_{m-1}, v_2), (v_2, v_{m-2}), \ldots \} \) until the cycle is decomposed into triangles. These cellulation edges can be placed in different layers.
Sparsity condition: Each edge in \(\bar{\bar{G}}\) participates in at most \(c\) generating cycles.
A base graph with cycles consists of:
A finite vertex type \(V\) with decidable equality
A simple graph \(G\) on \(V\) with decidable adjacency
A proof that \(G\) is connected
A finite index type \(\mathrm{CycleIdx}\) for the generating cycles
For each cycle index \(c\), an ordered list of vertices \(\texttt{cycleVertices}(c)\) representing a closed walk
Each cycle has length at least 3
Cycles are closed: the last vertex equals the first vertex
Consecutive vertices in a cycle are adjacent in the graph
Given a base graph with cycles \(G\) and a number of layers \(R\), the layered vertex type is defined as
where vertices are pairs \((i, v)\) consisting of a layer index \(i \in \{ 0, 1, \ldots , R\} \) and an original vertex \(v \in V\).
An intra-layer edge between layered vertices \(v\) and \(w\) is an edge within layer 0 (a copy of the original graph):
where \(v_1, w_1\) denote the layer indices and \(v_2, w_2\) denote the original vertices.
An inter-layer edge connects a vertex \(v\) in layer \(i\) to the same vertex in an adjacent layer:
Two vertices \(u\) and \(v\) are consecutive in cycle \(c\) if there exists an index \(i\) such that they appear as adjacent entries in the cycle’s vertex list:
where \(n\) is the length of the cycle.
For a cycle \((v_1, v_2, \ldots , v_m)\), the zigzag triangulation adds chords following the pattern: \(\{ (v_1, v_{m-1}), (v_{m-1}, v_2), (v_2, v_{m-2}), \ldots \} \)
A pair \((u, v)\) is a zigzag triangulation chord for cycle \(c\) if:
Both \(u\) and \(v\) are in the cycle
\(u \neq v\)
\(u\) and \(v\) are not consecutive in the cycle (so this is a chord, not an edge)
The cycle has length \(n \geq 4\) (triangles have no chords)
There exist indices \(i, j\) with \(i + 2 \leq j {\lt} n - 1\) such that \((u, v)\) corresponds to the chord \((\texttt{cycle}[i], \texttt{cycle}[j])\)
A cellulation assignment is a function that maps each cycle index to the layer where its cellulation edges are placed:
This allows distributing cellulation across layers to achieve sparsity.
A cellulation edge with assignment between layered vertices \(v\) and \(w\) exists if there is some cycle \(c\) such that:
Both vertices are in the layer assigned to cycle \(c\)
The underlying vertices form a zigzag triangulation chord for \(c\)
The sparsified adjacency relation with a given cellulation assignment defines when two layered vertices are adjacent:
For any cycle \(c\) and vertices \(u, v\), if \((u, v)\) is a zigzag triangulation chord then so is \((v, u)\):
Let \(h\) be the hypothesis that \((u, v)\) is a zigzag triangulation chord. Unfolding the definition, we obtain: \(u\) is in the cycle, \(v\) is in the cycle, \(u \neq v\), \((u, v)\) are not consecutive, \(n \geq 4\), and there exist indices \(i, j\) with the required chord property.
To show \((v, u)\) is also a zigzag triangulation chord, we verify:
\(v\) is in the cycle (from hypothesis)
\(u\) is in the cycle (from hypothesis)
\(v \neq u\) (by symmetry of inequality)
\((v, u)\) are not consecutive: if they were consecutive, then \((u, v)\) would be consecutive (by symmetry of the consecutive relation), contradicting our hypothesis
\(n \geq 4\) (from hypothesis)
The same indices \(i, j\) witness the chord property with \(u\) and \(v\) swapped
The sparsified adjacency relation with any assignment is symmetric.
Let \(v, w\) be layered vertices with \(v \neq w\) and suppose they are adjacent. We consider three cases:
Intra-layer edge: We have \(v_1 = 0\), \(w_1 = 0\), and \(G.\mathrm{Adj}(v_2, w_2)\). By symmetry of the graph adjacency, we get \(G.\mathrm{Adj}(w_2, v_2)\), hence \((w, v)\) is an intra-layer edge.
Inter-layer edge: We have \(v_2 = w_2\) and either \(v_1 + 1 = w_1\) or \(w_1 + 1 = v_1\). By symmetry, \((w, v)\) satisfies the same condition with the vertices swapped.
Cellulation edge: There exists a cycle \(c\) with \(v_1 = \mathrm{assign}(c)\), \(w_1 = \mathrm{assign}(c)\), and \((v_2, w_2)\) is a zigzag chord. By Theorem 581, \((w_2, v_2)\) is also a zigzag chord, so \((w, v)\) is a cellulation edge.
For any layered vertex \(v\), we have \(\neg \mathrm{sparsifiedAdjWithAssignment}(\mathrm{assign}, v, v)\).
Suppose \(v\) is adjacent to itself. By definition, this requires \(v \neq v\), which is a contradiction. Hence no vertex is adjacent to itself.
The sparsified graph with assignment is the simple graph on layered vertices with adjacency given by \(\mathrm{sparsifiedAdjWithAssignment}\). This is well-defined since the adjacency relation is symmetric and irreflexive.
An edge \((u, v)\) in the original graph participates in a generating cycle \(c\) if \(u\) and \(v\) are consecutive vertices in that cycle:
An edge \((u, v)\) is a cellulation chord for cycle \(c\) if it is a zigzag triangulation chord:
An edge in the sparsified graph participates in a generating cycle \(c\) (with a given cellulation assignment) if either:
It is an original edge of the cycle (in layer 0): \(v_1 = 0\), \(w_1 = 0\), and \(\mathrm{edgeIsInCycle}(c, v_2, w_2)\)
It is a cellulation chord in the assigned layer: \(v_1 = \mathrm{assign}(c)\), \(w_1 = \mathrm{assign}(c)\), and \(\mathrm{edgeIsCellulationFor}(c, v_2, w_2)\)
The set of generating cycles that an edge \((v, w)\) participates in is:
The cycle-degree of an edge \((v, w)\) with assignment is the number of generating cycles it participates in:
A cycle-sparsification with assignment satisfies the sparsity condition with cycle-degree bound \(c\) if every edge participates in at most \(c\) generating cycles:
The sparsity bound is inherited by any larger bound: if a cellulation assignment satisfies the sparsity bound \(c_1\) and \(c_1 \leq c_2\), then it also satisfies the sparsity bound \(c_2\).
Let \(\mathrm{assign}\) be a cellulation assignment satisfying the sparsity bound \(c_1\), and let \(c_1 \leq c_2\). For any edge \((v, w)\) in the sparsified graph, we have \(\mathrm{edgeCycleDegreeWithAssignment}(\mathrm{assign}, v, w) \leq c_1\) by hypothesis. By transitivity of \(\leq \), we obtain \(\mathrm{edgeCycleDegreeWithAssignment}(\mathrm{assign}, v, w) \leq c_2\).
A cycle-sparsified graph of a base graph \(G\) with cycle-degree bound \(c\) consists of:
A number of layers \(R\) (giving \(R+1\) total layers numbered \(0\) to \(R\))
A cellulation assignment mapping cycles to layers
A proof that the sparsity bound \(c\) is satisfied for all edges
The total number of layers in a cycle-sparsified graph \(S\) is \(R + 1\), where \(R\) is the number of layers minus one.
The number of vertices per layer in a cycle-sparsified graph is \(|V|\), the cardinality of the original vertex set.
The total number of vertices in a cycle-sparsified graph is:
The set of layer 0 vertices in a cycle-sparsified graph \(S\) is:
The set of vertices in layer \(i\) of a cycle-sparsified graph \(S\) is:
The underlying graph of a cycle-sparsified graph \(S\) is the sparsified graph constructed using \(S\)’s cellulation assignment.
Every edge of the original graph appears in layer 0 of the sparsified graph: for any vertices \(u, v \in V\) with \(G.\mathrm{Adj}(u, v)\), we have
We verify the two conditions for sparsified adjacency:
\((0, u) \neq (0, v)\): Suppose \((0, u) = (0, v)\). Then \(u = v\), but this contradicts the fact that \(G.\mathrm{Adj}(u, v)\) and simple graphs have no self-loops.
We show this is an intra-layer edge: both vertices are in layer 0, and \(G.\mathrm{Adj}(u, v)\) holds by hypothesis.
Only layer 0 has intra-layer edges: if \((v, w)\) is an intra-layer edge, then \(v_1 = 0\) and \(w_1 = 0\).
By definition of intra-layer edge, we have \(v_1 = 0\), \(w_1 = 0\), and \(G.\mathrm{Adj}(v_2, w_2)\). The first two conditions give the result directly.
Inter-layer edges exist between adjacent layers: for any layer \(i {\lt} R\) and vertex \(v \in V\),
We verify the two conditions for sparsified adjacency:
\((i, v) \neq (i+1, v)\): The layer indices differ since \(i \neq i+1\).
We show this is an inter-layer edge: both vertices have the same underlying vertex \(v\), and the layer indices satisfy \(i + 1 = i + 1\).
A cycle-sparsification exists with \(R\) layers and cycle-degree bound \(c\) if there exists a cellulation assignment achieving the sparsity bound:
The set of valid layer counts for a given cycle-degree bound \(c\) is:
The minimum number of layers \(R_G^c\) required for a cycle-sparsification with cycle-degree bound \(c\) is defined as:
If a sparsification exists with \(R\) layers, then the minimum is at most \(R\):
By definition, \(R_G^c\) is the infimum of the set of valid layer counts. If \(R\) is in this set (i.e., a sparsification exists with \(R\) layers), then the infimum is at most \(R\), by the property \(\mathrm{sInf\_ le}\) of natural number infima.
When a sparsification exists, the minimum layers value is itself valid:
Since the set of valid layer counts is non-empty (by hypothesis), the infimum is achieved and is a member of the set, by the property \(\mathrm{sInf\_ mem}\) of natural number infima.
No smaller value works: if \(R {\lt} R_G^c\), then no sparsification exists with \(R\) layers:
Suppose for contradiction that \(R {\lt} R_G^c\) and a sparsification exists with \(R\) layers. Then \(R\) is in the set of valid layer counts, so the infimum \(R_G^c \leq R\) by \(\mathrm{sInf\_ le}\). But this contradicts \(R {\lt} R_G^c\).
The number of triangles in any triangulation of an \(n\)-gon (for \(n \geq 3\)) is \(n - 2\). Equivalently, \((n - 2) + 2 = n\).
This follows by arithmetic: \(n - 2 + 2 = n\).
The number of chords needed to triangulate an \(n\)-gon (for \(n \geq 3\)) is \(n - 3\). Equivalently, \((n - 3) + 3 = n\).
This follows by arithmetic: \(n - 3 + 3 = n\).
A triangle (3-cycle) needs no additional chords for triangulation: for any cycle \(c\) with length 3 and any vertices \(u, v\), we have \(\neg \mathrm{isZigzagTriangulationChord}(c, u, v)\).
Suppose \((u, v)\) is a zigzag triangulation chord for cycle \(c\). By definition, this requires the cycle length \(n \geq 4\). But \(n = 3\) by hypothesis, which is a contradiction.
The Freedman-Hastings decongestion lemma (as a specification) states that for any constant-degree graph \(G\) with \(W\) vertices, \(R_G^c = O(\log ^2 W)\) for constant cycle-degree bound \(c\).
Formally, there exist constants \(A, B\) such that for all base graphs \(G\) with maximum degree at most \(\mathrm{maxDegree}\):
For layered vertices \(v, w\) with \(v_1 = 0\) and \(w_1 = 0\):
By definition, \(\mathrm{isIntraLayerEdge}(v, w)\) requires \(v_1 = 0\), \(w_1 = 0\), and \(G.\mathrm{Adj}(v_2, w_2)\). Since the first two conditions are given by hypothesis, the equivalence reduces to the third condition.
Inter-layer edges connect the same vertex across adjacent layers: if \(\mathrm{isInterLayerEdge}(v, w)\), then \(v_2 = w_2\).
By definition of inter-layer edge, we have \(v_2 = w_2\) as the first conjunct.
An intra-layer edge connects distinct vertices: if \(\mathrm{isIntraLayerEdge}(v, w)\), then \(v \neq w\).
Suppose \(v = w\). Then \(v_2 = w_2\), and by the definition of intra-layer edge, we have \(G.\mathrm{Adj}(w_2, w_2)\). But simple graphs have no self-loops, so this is a contradiction.
The total vertex count is the product of layers and vertices per layer:
This holds by definition (reflexivity).
Each layer has the same number of vertices as the original graph:
The filter selects all pairs \((i, v)\) for \(v \in V\). The function \(v \mapsto (i, v)\) is injective (if \((i, x) = (i, y)\) then \(x = y\)). The filtered set equals the image of this injection on \(V\), so its cardinality equals \(|V|\).
If there are no generating cycles (\(|\mathrm{CycleIdx}| = 0\)), then the sparsity bound 0 is satisfied for any cellulation assignment.
For any edge \((v, w)\), the set of cycles containing it is a subset of the universal set of cycle indices. Since \(|\mathrm{CycleIdx}| = 0\), the universal set is empty, so the filtered set is also empty. Therefore the edge cycle degree is 0, which is at most 0.
The sparsity bound is always satisfied for \(c = |\mathrm{CycleIdx}|\) (the total number of cycles).
For any edge \((v, w)\), the set of cycles containing it is a subset of the universal set of cycle indices. Therefore:
For any graph, a sparsification exists with at least one layer when using a bound equal to the total number of cycles.
We use \(R = 0\) (giving a single layer). Define the cellulation assignment to map all cycles to layer 0. By Theorem 618, this assignment satisfies the sparsity bound \(c = |\mathrm{CycleIdx}|\).
[Cycle Sparsification Bounds]
This remark establishes asymptotic bounds for cycle sparsification in constant-degree graphs.
For a constant degree graph \(G\) with \(|V| = W\) vertices:
Number of cycles: A minimal generating set of cycles has size \(|E| - |V| + 1 = \Theta (W)\) for constant-degree graphs.
Random expander expectation: For a random expander graph, almost all generating cycles have length \(O(\log W)\). In this case:
Cycle-degree (before sparsification) \(= O(\log W)\)
Number of layers for sparsification: \(R_G^c = O(\log W)\)
Worst-case bound (Freedman-Hastings decongestion lemma): For any constant-degree graph, \(R_G^c = O(\log ^2 W)\).
Best case: For some structured graphs (e.g., surface code lattice surgery), \(R_G^c = O(1)\) — no sparsification needed.
Implication for qubit overhead: The total number of auxiliary qubits in the cycle-sparsified graph is:
This yields the \(O(W \log ^2 W)\) overhead bound for the gauging measurement procedure.
What is proven in this formalization:
Handshaking lemma: \(2|E| \leq d|V|\) for degree-\(d\) graphs
Edge count lower bound: \(|E| \geq |V| - 1\) for connected graphs
Cycle rank \(\Theta (W)\) for constant-degree graphs with \(d \geq 3\):
Upper bound: \(\text{cycle\_ rank} \leq (d/2)|V|\)
Lower bound: \(\text{cycle\_ rank} \geq (d-2)/2 \cdot |V|/d\) for \(d\)-regular graphs
Big-\(O\) notation properties
Overhead function hierarchy: \(W \leq W \log W \leq W \log ^2 W\)
Cited from literature (specifications only):
Freedman-Hastings decongestion lemma: \(R_G^c = O(\log ^2 W)\)
Random expander cycle lengths: \(O(\log W)\)
No proof needed for remarks.
A function \(f : \mathbb {N} \to \mathbb {N}\) is \(O(g)\) if there exist constants \(C, N \in \mathbb {N}\) such that \(C {\gt} 0\) and for all \(n \geq N\), we have \(f(n) \leq C \cdot g(n)\).
A function \(f : \mathbb {N} \to \mathbb {N}\) is \(\Omega (g)\) (big-Omega) if there exist constants \(C, N \in \mathbb {N}\) such that \(C {\gt} 0\) and for all \(n \geq N\), we have \(f(n) \geq C \cdot g(n)\).
A function \(f : \mathbb {N} \to \mathbb {N}\) is \(\Theta (g)\) if \(f\) is both \(O(g)\) and \(\Omega (g)\).
A function \(f : \mathbb {N} \to \mathbb {N}\) is \(O(\log ^2 n)\) if \(f\) is \(O(n \mapsto (\log _2 n)^2 + 1)\).
A function \(f : \mathbb {N} \to \mathbb {N}\) is \(O(\log n)\) if \(f\) is \(O(n \mapsto \log _2 n + 1)\).
A function \(f : \mathbb {N} \to \mathbb {N}\) is \(O(1)\) (i.e., bounded) if there exists a constant \(C \in \mathbb {N}\) such that for all \(n\), \(f(n) \leq C\).
A graph configuration \(G\) has constant maximum degree \(d\) if every vertex has degree at most \(d\):
A graph \(G\) is \(d\)-regular if every vertex has exactly degree \(d\):
If \(G\) is a \(d\)-regular graph, then \(G\) has constant degree \(d\).
Let \(v\) be an arbitrary vertex. Since \(G\) is \(d\)-regular, we have \(\deg (v) = d\). By reflexivity of equality, \(\deg (v) \leq d\). Since \(v\) was arbitrary, \(G\) has constant degree \(d\).
For a constant degree \(d\) graph \(G\), we have the handshaking lemma bound:
By the handshaking lemma, \(\sum _{v \in V} \deg (v) = 2|E|\). Since \(\deg (v) \leq d\) for all vertices \(v\), we have:
For a \(d\)-regular graph \(G\):
By the handshaking lemma, \(\sum _{v \in V} \deg (v) = 2|E|\). Since \(G\) is \(d\)-regular, \(\deg (v) = d\) for all \(v\):
For a constant degree \(d\) graph \(G\):
From the handshaking lemma bound \(2|E| \leq d \cdot |V|\), the result follows by integer arithmetic.
For a connected graph \(G\):
By the connectivity property of \(G\), the graph has a spanning tree. A tree on \(|V|\) vertices has exactly \(|V| - 1\) edges. Since the spanning tree is a subgraph, \(|E| \geq |V| - 1\), which gives \(|E| + 1 \geq |V|\).
The cycle rank of a connected graph \(G\) is defined as the first Betti number:
For constant degree graphs with \(d = O(1)\), this is \(\Theta (|V|)\).
For a constant degree \(d\) graph \(G\):
By definition, \(\text{CycleRank}(G) = |E| - |V| + 1\). From the handshaking lemma, \(2|E| \leq d \cdot |V|\), so \(|E| \leq \frac{d \cdot |V|}{2}\). Therefore:
For a connected graph \(G\):
Since \(G\) is connected, we have \(|E| + 1 \geq |V|\), which means \(|E| \geq |V| - 1\). Therefore:
For a \(d\)-regular graph \(G\) with \(d \geq 3\):
For \(d\)-regular graphs, \(2|E| = d|V|\). From \(d \geq 3\), we have \(2|E| \geq 3|V|\). Converting to integers, \(2|E| \geq 3|V|\).
We show \(2(\text{CycleRank}(G)) \geq |V|\):
From \(2x \geq y\), we get \(x \geq y/2\) by integer division, so \(\text{CycleRank}(G) \geq |V|/2\).
For a \(d\)-regular graph \(G\) with \(d \geq 3\):
Both bounds are linear in \(|V|\), establishing \(\text{CycleRank}(G) = \Theta (|V|)\).
We prove each direction separately. The lower bound \(\text{CycleRank}(G) \geq |V|/2\) follows from the lower bound theorem for regular graphs. For the upper bound, since regular graphs satisfy the constant degree bound, the upper bound theorem applies. Since \(|V| \geq 1\) (the graph is connected and nonempty), we have:
For a constant degree \(d\) graph \(G\):
The cycle rank is nonnegative, and \(|E| \leq d|V|/2\) by the edge count bound. Since \(|V| \geq 1\) for a connected graph, we have \(\text{CycleRank}(G) = |E| - |V| + 1 \leq |E| \leq d|V|/2\).
The total number of auxiliary qubits in the cycle-sparsified graph is:
where the sum is over all cycles \(c\) in the generating set, and \(\text{len}(c) - 3\) is the number of chords needed to triangulate an \(\text{len}(c)\)-gon.
For \(R_1 \leq R_2\):
By definition of totalAuxQubits, we apply monotonicity of addition on the right, then monotonicity of addition on the left, and finally monotonicity of multiplication: \(R_1 \cdot |V| \leq R_2 \cdot |V|\) since \(R_1 \leq R_2\).
The cellulation term is bounded by the total cycle length:
For each cycle \(c\), we have \(\text{len}(c) - 3 \leq \text{len}(c)\) by integer arithmetic. The result follows by summing over all cycles.
For a constant degree \(d\) graph \(G\) with at most \(d|V|/2\) cycles, each of length at most \(|V|\):
We bound each term:
\(|E| \leq d|V|/2\) by the edge count bound.
\(R \cdot |V|\) is preserved.
The cellulation term is bounded by \(\sum _c \text{len}(c) \leq \sum _c |V| = (\text{number of cycles}) \cdot |V| \leq (d|V|/2) \cdot |V|\).
Adding these bounds gives the result.
A classification of graph types by their sparsification behavior:
general: Claimed \(O(\log ^2 W)\) layers (Freedman-Hastings)
expander: Claimed \(O(\log W)\) layers (random expanders)
structured: Claimed \(O(1)\) layers (e.g., surface codes)
The claimed layer count for each graph type:
The overhead bound function \(W\) times the layer bound:
For \(W \geq 4\):
We have \(\text{overhead}(\text{expander}, W) = W \cdot (\log _2 W + 1)\) and \(\text{overhead}(\text{general}, W) = W \cdot ((\log _2 W)^2 + 1)\).
By monotonicity of multiplication, it suffices to show \(\log _2 W + 1 \leq (\log _2 W)^2 + 1\), i.e., \(\log _2 W \leq (\log _2 W)^2\).
Since \(W \geq 4\), we have \(\log _2 W \geq \log _2 4 = 2 \geq 1\). For \(x \geq 1\), we have \(x = x \cdot 1 \leq x \cdot x = x^2\). Thus \(\log _2 W \leq (\log _2 W)^2\), and by integer arithmetic the result follows.
For \(W \geq 2\):
We have \(\text{overhead}(\text{structured}, W) = W\) and \(\text{overhead}(\text{expander}, W) = W \cdot (\log _2 W + 1)\).
Since \(W \geq 2\), we have \(\log _2 W \geq \log _2 2 = 1\), so \(\log _2 W + 1 \geq 1\). Therefore:
For \(W \geq 4\):
By transitivity: \(\text{overhead}(\text{structured}, W) \leq \text{overhead}(\text{expander}, W)\) (since \(W \geq 4 \geq 2\)), and \(\text{overhead}(\text{expander}, W) \leq \text{overhead}(\text{general}, W)\) (since \(W \geq 4\)).
For \(W \geq 4\):
We verify both conditions. The first inequality follows from the structured-expander theorem (with \(W \geq 4 \geq 2\)), and the second from the expander-general theorem.
For any function \(f\): \(f = O(f)\).
Take \(C = 1\) and \(N = 0\). Since \(C = 1 {\gt} 0\), and for all \(n \geq 0\), \(f(n) \leq 1 \cdot f(n) = f(n)\) by reflexivity and ring normalization, we have \(f = O(f)\).
If \(f = O(g)\) and \(g = O(h)\), then \(f = O(h)\).
Assume \(f = O(g)\) with constants \(C_1, N_1\) (so \(C_1 {\gt} 0\) and \(f(n) \leq C_1 g(n)\) for \(n \geq N_1\)), and \(g = O(h)\) with constants \(C_2, N_2\) (so \(C_2 {\gt} 0\) and \(g(n) \leq C_2 h(n)\) for \(n \geq N_2\)).
Take \(C = C_1 C_2\) and \(N = \max (N_1, N_2)\). Since \(C_1 {\gt} 0\) and \(C_2 {\gt} 0\), we have \(C = C_1 C_2 {\gt} 0\).
For \(n \geq N\), we have \(n \geq N_1\) and \(n \geq N_2\), so:
Thus \(f = O(h)\).
For any constant \(c\), the function \(n \mapsto c\) is \(O(1)\).
Take \(C = c\). For all \(n\), \(f(n) = c \leq c = C\). Thus \(f\) is \(O(1)\).
If \(f\) is \(O(1)\), then \(f\) is \(O(\log n)\).
Assume \(f\) is \(O(1)\) with bound \(C\), so \(f(n) \leq C\) for all \(n\). Take \(C' = C + 1\) and \(N = 0\). Since \(C' = C + 1 {\gt} 0\), and for all \(n \geq 0\):
since \(\log _2 n + 1 \geq 1\). Thus \(f = O(\log n)\).
If \(f\) is \(O(\log n)\), then \(f\) is \(O(\log ^2 n)\).
Assume \(f = O(\log n)\) with constants \(C, N\), so \(f(n) \leq C(\log _2 n + 1)\) for \(n \geq N\).
For \(n \geq N\):
since \(\log _2 n + 1 \leq (\log _2 n)^2 + 1\) (as \(x + 1 \leq x^2 + 1\) follows from \(x \leq x^2\) which holds by nonlinear arithmetic for natural numbers). Thus \(f = O(\log ^2 n)\).
The identity function is \(O(n)\).
This follows directly from reflexivity of Big-O.
For all \(n\): \(\log _2 n \leq n\).
This is a standard property of logarithms from Mathlib.
For all \(n\): \((\log _2 n)^2 \leq n^2\).
Since \(\log _2 n \leq n\), we have:
by monotonicity of multiplication.
For any graph \(G\) and constant \(c\):
This holds trivially since the function returns a natural number.
If \(S\) is a CycleSparsifiedGraph for \(G\) with constant \(c\), then sparsification with \(S.\text{numLayers}\) layers exists.
From the structure \(S\), we obtain the cellulation assignment \(S.\text{cellulationAssignment}\) and the sparsity bound \(S.\text{sparsityBound}\). These directly witness the existence of sparsification.
The overhead functions satisfy:
That is, structured overhead is \(O\)(expander overhead) and expander overhead is \(O\)(general overhead).
We verify both conditions separately.
For structured \(= O\)(expander): Take \(C = 1\) and \(N = 2\). Since \(1 {\gt} 0\), and for all \(n \geq 2\), by the structured-expander theorem:
For expander \(= O\)(general): Take \(C = 1\) and \(N = 4\). Since \(1 {\gt} 0\), and for all \(n \geq 4\), by the expander-general theorem:
SPECIFICATION (Cited from literature): The Freedman-Hastings decongestion lemma states that for any constant-degree graph \(G\) with \(W\) vertices, \(R_G^c = O(\log ^2 W)\).
Formally: There exist constants \(A, B\) such that for all graphs \(G\) with maximum degree at most \(d\), if sparsification exists, then:
Note: This is a cited result requiring topological decomposition techniques and the full Freedman-Hastings machinery.
SPECIFICATION (Cited from literature): For random \(d\)-regular expander graphs, almost all cycles in a minimal generating set have length \(O(\log W)\).
Formally: There exists a constant \(C\) such that for all \(d\)-regular expander graphs \(G\) and all cycles \(c\) in the generating set:
Note: This is a cited result from random graph theory.
SPECIFICATION: Some specific graph families (like surface code lattices) achieve \(R_G^c = O(1)\), meaning no sparsification is needed.
Formally: There exists a graph \(G\) such that:
Note: This is true by construction for such graphs — they are designed to have bounded cycle degree.
For a \(d\)-regular graph \(G\) with \(d \geq 3\), the cycle rank is \(\Theta (|V|)\):
This follows directly from the cycle rank \(\Theta (|V|)\) theorem for regular graphs.
For \(W \geq 4\), the overhead functions satisfy the complete hierarchy:
We verify all three conditions. The first inequality follows from the structured-expander theorem (since \(W \geq 4 \geq 2\)). The second follows from the expander-general theorem (since \(W \geq 4\)). The third is by definition of the overhead bound function for general graphs.
[Sparsified Deformed Checks]
When using a cycle-sparsification \(\bar{\bar{G}}\) of the gauging graph \(G\), the deformed checks are chosen to exploit the layered structure:
Flux operators \(B_p\): Use a generating set of cycles with weight \(\leq 4\):
Square cycles: For each edge \(e\) in layer \(i {\lt} R\) and its copy \(e'\) in layer \(i+1\), the square formed by \(e\), \(e'\), and the inter-layer edges has weight 4.
Triangle cycles: The cellulated triangles from the original cycles have weight 3.
Deformed checks \(\tilde{s}_j\): The paths \(\gamma _j\) for deforming original checks are all routed through layer 0 (the original \(G\)).
Degree analysis: Assuming \(G\) has constant degree \(\Delta \) and paths \(\gamma _j\) have length bounded by \(\kappa \):
Number of paths through any edge in layer 0: \(\leq 2\Delta ^\kappa \cdot w\) where \(w\) is the max check weight
This is constant when \(\Delta , \kappa , w\) are all constant.
Result: The deformed code is LDPC (constant weight checks, constant degree qubits) when:
The original code is LDPC
The gauging graph \(G\) has constant degree
The path lengths \(|\gamma _j|\) are bounded by a constant
No proof needed for remarks.
A classification of flux cycle types in a sparsified graph:
Square: A square cycle with weight 4, connecting an edge across adjacent layers.
Triangle: A triangle cycle with weight 3, arising from cycle cellulation.
The weight of each cycle type is defined as:
For all cycle types \(t\), we have \(\text{weight}(t) \leq 4\).
We consider the two cases. If \(t = \text{square}\), then \(\text{weight}(t) = 4 \leq 4\). If \(t = \text{triangle}\), then \(\text{weight}(t) = 3 \leq 4\). By simplification using the definition of weight, the result follows.
For all cycle types \(t\), we have \(\text{weight}(t) {\gt} 0\).
We consider the two cases. If \(t = \text{square}\), then \(\text{weight}(t) = 4 {\gt} 0\). If \(t = \text{triangle}\), then \(\text{weight}(t) = 3 {\gt} 0\). By simplification using the definition of weight, the result follows.
A sparsified flux configuration for a graph \(G\) with cycle sparsification \(S\) consists of:
An index type \(\text{SquareCycleIdx}\) for square cycles (finite)
An index type \(\text{TriangleCycleIdx}\) for triangle cycles (finite)
A function \(\text{squareEdges} : \text{SquareCycleIdx} \to \text{Finset}(\text{Sym}_2(\text{LayeredVertex}))\) with each set having exactly 4 edges
A function \(\text{triangleEdges} : \text{TriangleCycleIdx} \to \text{Finset}(\text{Sym}_2(\text{LayeredVertex}))\) with each set having exactly 3 edges
The total number of flux cycles in a sparsified flux configuration \(F\) is:
The maximum weight of any cycle in a sparsified flux configuration is 4 (the weight of square cycles).
For any sparsified flux configuration \(F\):
For all \(i\), \(|\text{squareEdges}(i)| \leq 4\)
For all \(i\), \(|\text{triangleEdges}(i)| \leq 4\)
We prove both parts separately. For the first part, let \(i\) be arbitrary. By the configuration property, \(|\text{squareEdges}(i)| = 4 \leq 4\). For the second part, let \(i\) be arbitrary. By the configuration property, \(|\text{triangleEdges}(i)| = 3\), and by integer arithmetic, \(3 \leq 4\).
A square cycle connecting an edge across adjacent layers consists of:
A layer index \(\text{layer} : \text{Fin}(R)\) (must be \({\lt} R\) for layer \(i+1\) to exist)
First endpoint \(u : G.V\) of the horizontal edge
Second endpoint \(v : G.V\) of the horizontal edge
Adjacency proof \(\text{adj} : G.\text{graph}.\text{Adj}(u, v)\)
The square is formed by:
\((i, u) - (i, v)\): horizontal edge \(e\) in layer \(i\)
\((i+1, u) - (i+1, v)\): horizontal edge \(e'\) in layer \(i+1\)
\((i, u) - (i+1, u)\): vertical inter-layer edge
\((i, v) - (i+1, v)\): vertical inter-layer edge
The four edges of a square cycle \(\text{sq}\) are:
where:
\(\text{lowerEdge} = \{ (i, u), (i, v)\} \)
\(\text{upperEdge} = \{ (i+1, u), (i+1, v)\} \)
\(\text{leftEdge} = \{ (i, u), (i+1, u)\} \)
\(\text{rightEdge} = \{ (i, v), (i+1, v)\} \)
For any square cycle \(\text{sq}\), \(|\text{edges}(\text{sq})| \leq 4\).
By the definition of edges, we are inserting at most 4 elements into a finite set. The result follows by Finset.card_le_four, which states that any set of the form \(\{ a, b, c, d\} \) has cardinality at most 4.
A triangle cycle from cellulation consists of:
A layer \(\text{layer} : \text{Fin}(R+1)\) where the triangle is placed
Three distinct vertices \(v_1, v_2, v_3 : G.V\) with proofs \(v_1 \neq v_2\), \(v_2 \neq v_3\), and \(v_1 \neq v_3\)
The three edges of a triangle cycle \(\text{tri}\) are:
where \(\ell \) is the layer of the triangle.
For any triangle cycle \(\text{tri}\), \(|\text{edges}(\text{tri})| \leq 3\).
By the definition of edges, we are inserting at most 3 elements into a finite set. The result follows by Finset.card_le_three, which states that any set of the form \(\{ a, b, c\} \) has cardinality at most 3.
The weight of a triangle cycle is defined as \(\text{cycleWeight}(\text{tri}) = 3\).
For any triangle cycle \(\text{tri}\), \(\text{cycleWeight}(\text{tri}) = \text{weight}(\text{triangle})\).
This holds by reflexivity, as both sides equal 3 by definition.
An edge path restricted to layer 0 in a sparsified graph consists of:
A finite set of edges \(\text{edges} : \text{Finset}(\text{Sym}_2(G.V))\)
A proof that all edges are valid in the original graph: \(\forall e \in \text{edges}, e \in G.\text{graph}.\text{edgeSet}\)
The length of a layer 0 routed path is the cardinality of its edge set:
The empty path has an empty edge set.
The empty layer 0 path has length 0.
This follows directly from Finset.card_empty, as the empty path has an empty edge set.
Parameters for degree analysis consist of:
\(\text{graphDegree}\): Maximum degree of the gauging graph (\(\Delta \))
\(\text{pathLengthBound}\): Maximum path length for deformed checks (\(\kappa \))
\(\text{maxCheckWeight}\): Maximum weight of original checks (\(w\))
The edge degree formula is:
where \(\Delta = \text{graphDegree}\), \(\kappa = \text{pathLengthBound}\), and \(w = \text{maxCheckWeight}\).
The edge degree formula equals \(2 \cdot \text{graphDegree}^{\text{pathLengthBound}} \cdot \text{maxCheckWeight}\).
This holds by reflexivity (definition of edgeDegreeFormula).
For any degree analysis parameters and \(d' \geq \text{graphDegree}\):
We have \(\text{edgeDegreeFormula} = 2 \cdot \Delta ^\kappa \cdot w\). We apply monotonicity of multiplication on the right by \(w\), then monotonicity of multiplication on the left by \(2\), then monotonicity of exponentiation with fixed exponent: \(\Delta ^\kappa \leq (d')^\kappa \) when \(\Delta \leq d'\).
For any degree analysis parameters with \(\text{graphDegree} \geq 1\) and \(\kappa ' \geq \text{pathLengthBound}\):
We have \(\text{edgeDegreeFormula} = 2 \cdot \Delta ^\kappa \cdot w\). We apply monotonicity of multiplication on the right by \(w\), then monotonicity of multiplication on the left by \(2\), then monotonicity of exponentiation with fixed base \(\geq 1\): \(\Delta ^\kappa \leq \Delta ^{\kappa '}\) when \(\kappa \leq \kappa '\) and \(\Delta \geq 1\).
For any degree analysis parameters and \(w' \geq \text{maxCheckWeight}\):
We have \(\text{edgeDegreeFormula} = 2 \cdot \Delta ^\kappa \cdot w\). The result follows by monotonicity of multiplication on the left: \((2 \cdot \Delta ^\kappa ) \cdot w \leq (2 \cdot \Delta ^\kappa ) \cdot w'\) when \(w \leq w'\).
If \(\text{graphDegree} = 0\) and \(\text{pathLengthBound} {\gt} 0\), then \(\text{edgeDegreeFormula} = 0\).
We have \(\text{edgeDegreeFormula} = 2 \cdot 0^\kappa \cdot w\) where \(\kappa {\gt} 0\). Since \(\kappa \neq 0\), we have \(0^\kappa = 0\), so \(2 \cdot 0 \cdot w = 0\).
A structure capturing the edge degree bound in layer 0, requiring that for all vertices \(v\) in the graph, \(\text{degree}(v) \leq \text{graphDegree}\).
The edge degree bound in layer 0 is defined as the edge degree formula:
The edge degree bound equals \(2 \cdot \text{graphDegree}^{\text{pathLengthBound}} \cdot \text{maxCheckWeight}\).
This holds by reflexivity.
LDPC (Low-Density Parity-Check) conditions for a code consist of:
\(\text{maxCheckWeight}\): Maximum weight of any check
\(\text{maxQubitDegree}\): Maximum degree of any qubit (number of checks it participates in)
A stabilizer code \(C\) is LDPC with conditions \(\text{ldpc}\) if:
For all checks \(j\), \(\text{weight}(C.\text{checks}(j)) \leq \text{maxCheckWeight}\)
For all qubits \(i\), the number of checks containing \(i\) in their X or Z support is at most \(\text{maxQubitDegree}\)
Combined LDPC conditions for a sparsified deformed code extend the basic LDPC conditions with:
\(\text{graphDegree}\): Maximum degree of gauging graph (\(\Delta \))
\(\text{pathLengthBound}\): Maximum path length for deformed checks (\(\kappa \))
The edge degree bound from routing is:
The deformed check weight bound is:
where \(w = \text{maxCheckWeight}\) and \(\kappa = \text{pathLengthBound}\).
The deformed check weight bound equals \(\text{maxCheckWeight} + \text{pathLengthBound}\).
This holds by reflexivity.
Convert sparsified LDPC conditions to degree analysis parameters by extracting \((\Delta , \kappa , w)\).
The edge degree equals the edge degree formula of the corresponding degree parameters.
This holds by reflexivity.
The flux operator weight bound is defined as \(\text{fluxWeightBound} = 4\).
The flux weight bound equals 4.
This holds by reflexivity.
A sparsified deformed code configuration with all its parameters consists of:
\(\text{ldpc}\): Parameters for LDPC analysis
\(\text{numGaussLaw}\): Number of Gauss law operators (vertices in the layered graph)
\(\text{numFlux}\): Number of flux operators (square + triangle cycles)
\(\text{numDeformedChecks}\): Number of deformed checks (original checks)
\(\text{numQubits}\): Number of qubits (edges in the layered graph)
The upper bound on deformed check weight is:
The Gauss law operator weight \((\Delta + 1)\) is at most the upper bound:
By the definition of deformedCheckWeightUpperBound, \(\Delta + 1\) is the left argument of the outer max, so \(\Delta + 1 \leq \max (\Delta + 1, \cdot )\).
The flux operator weight (\(\leq 4\)) is at most the upper bound:
We have \(4 \leq \max (4, w + \kappa )\) since 4 is the left argument of this max. Then \(\max (4, w + \kappa ) \leq \max (\Delta + 1, \max (4, w + \kappa ))\) since it is the right argument of the outer max.
The deformed check weight \((w + \kappa )\) is at most the upper bound:
We have \(w + \kappa \leq \max (4, w + \kappa )\) since \(w + \kappa \) is the right argument of this max. Then \(\max (4, w + \kappa ) \leq \max (\Delta + 1, \max (4, w + \kappa ))\) since it is the right argument of the outer max.
The upper bound on deformed qubit degree is:
where \(c\) is the cycle degree.
Given LDPC conditions \(\text{ldpc}\) and cycle degree \(c\), the following bounds hold:
Gauss law weight bounded: \(\Delta + 1 \leq \text{deformedCheckWeightUpperBound}(\text{ldpc})\)
Flux weight bounded: \(\text{fluxWeightBound} \leq \text{deformedCheckWeightUpperBound}(\text{ldpc})\)
Deformed check weight bounded: \(\text{deformedCheckWeightBound} \leq \text{deformedCheckWeightUpperBound}(\text{ldpc})\)
Qubit degree bounded: \(\text{edgeDegree} + c + 2 \leq \text{deformedQubitDegreeUpperBound}(\text{ldpc}, c)\)
We verify each bound separately:
The Gauss law bound follows from gaussLaw_le_upperBound.
The flux bound follows from flux_le_upperBound, noting that fluxWeightBound = 4.
The deformed check bound follows from deformedCheck_le_upperBound, noting that deformedCheckWeightBound = \(w + \kappa \).
For the qubit degree bound, unfolding the definitions gives \(2\Delta ^\kappa w + c + 2 \leq 2\Delta ^\kappa w + c + 2\), which follows by integer arithmetic (omega).
The maximum weight of all generator types is:
The maximum generator weight bounds all generator types:
\(\Delta + 1 \leq \text{maxGeneratorWeight}(\text{ldpc})\)
\(\text{fluxWeightBound} \leq \text{maxGeneratorWeight}(\text{ldpc})\)
\(\text{deformedCheckWeightBound} \leq \text{maxGeneratorWeight}(\text{ldpc})\)
We verify each bound:
\(\Delta + 1 \leq \max (\Delta + 1, \cdot )\) by Nat.le_max_left.
\(\text{fluxWeightBound} \leq \max (\text{fluxWeightBound}, \cdot )\) by Nat.le_max_left, and this is \(\leq \max (\cdot , \max (\text{fluxWeightBound}, \cdot ))\) by Nat.le_trans and Nat.le_max_right.
Similarly, \(\text{deformedCheckWeightBound} \leq \max (\cdot , \text{deformedCheckWeightBound})\) by Nat.le_max_right, and this is \(\leq \max (\cdot , \max (\cdot , \text{deformedCheckWeightBound}))\) by Nat.le_trans and Nat.le_max_right.
The total qubit count for a sparsified deformed code is:
where \(n_{\text{original}}\) is the number of original qubits, \(W\) is the number of edges per layer, and \(R\) is the number of additional layers.
The qubit overhead formula is \(n_{\text{original}} + W \cdot (R + 1)\).
This holds by reflexivity.
For \(R = (\log _2 W)^2\), the total qubit count is:
This holds by reflexivity.
The weight of a Gauss law operator at vertex \(v\) is:
For any vertex \(v\) with \(\text{degree}(v) \leq \Delta \):
By the definition of gaussLawWeight, we have \(\text{gaussLawWeight}(G, v) = \text{degree}(v) + 1 \leq \Delta + 1\) when \(\text{degree}(v) \leq \Delta \). The result follows by integer arithmetic (omega).
If graph \(G\) has constant degree \(\Delta \), then for all vertices \(v\):
Let \(v\) be arbitrary. Since \(G\) has constant degree \(\Delta \), we have \(\text{degree}(v) \leq \Delta \). The result follows by gaussLawWeight_bound.
The edge degree in a sparsified graph consists of:
\(\text{gaussLawDegree}\): Degree from Gauss law operators
\(\text{fluxDegree}\): Degree from flux operators
\(\text{deformedCheckDegree}\): Degree from deformed checks
The total edge degree is:
The edge degree for inter-layer edges with cycle degree \(c\) is:
\(\text{gaussLawDegree} = 2\) (two endpoints)
\(\text{fluxDegree} = c\) (cycle degree bound)
\(\text{deformedCheckDegree} = 0\) (no deformed checks use inter-layer edges when routed in layer 0)
The total inter-layer edge degree is:
By the definitions, \(\text{total} = 2 + c + 0 = c + 2\). The result follows by ring arithmetic.
The deformed code’s maximum check weight equals:
This holds by reflexivity.
The deformed code’s maximum qubit degree equals:
This holds by reflexivity.
The sparsified deformed code is LDPC: all check weights and qubit degrees are bounded by constants depending only on the parameters \((\Delta , \kappa , w, c)\).
This follows directly from deformedCode_is_LDPC.
If all parameters \((w, \Delta , \kappa , c)\) are finite natural numbers, then the deformed check weight upper bound and deformed qubit degree upper bound are both finite.
For both bounds, we need to show they are less than themselves plus 1. This follows immediately by integer arithmetic (omega).
If \(\kappa = 0\), then \(\text{deformedCheckWeightBound} = w\).
By the definition, \(\text{deformedCheckWeightBound} = w + \kappa = w + 0 = w\). The result follows by ring arithmetic.
For all \(\Delta , \kappa , w\):
This follows by ring arithmetic.
For any LDPC conditions:
This follows by integer arithmetic (omega).
The total generator count formula is:
This holds by reflexivity.
If \(\Delta = 0\) and \(\kappa {\gt} 0\), then \(\text{edgeDegree} = 0\).
We have \(\text{edgeDegree} = 2 \cdot 0^\kappa \cdot w\). Since \(\kappa {\gt} 0\), we have \(\kappa \neq 0\), so \(0^\kappa = 0\). Therefore \(2 \cdot 0 \cdot w = 0\).
[Desiderata for Gauging Graph]
When choosing a constant-degree gauging graph \(G = (V, E)\) for measuring a logical operator \(L\), the following desiderata should be satisfied:
Short deforming paths: \(G\) should contain a constant-length edge-path between any pair of vertices that are in the \(Z\)-type support of some check from the original code. Specifically: for each check \(s_j\) with \(\mathcal{S}_{Z,j} \cap V \neq \emptyset \), there exists a path \(\gamma _j \subseteq E\) with \(|\gamma _j| \leq \kappa \) for some constant \(\kappa \).
Sufficient expansion: The Cheeger constant should satisfy \(h(G) \geq 1\). This ensures no distance reduction in the deformed code.
Low-weight cycle basis: There should exist a generating set of cycles \(C\) where each cycle has weight bounded by a constant. Combined with cycle-sparsification, this ensures the flux operators \(B_p\) have constant weight.
When all desiderata are satisfied:
The deformed code is LDPC
The code distance is preserved: \(d_{\text{deformed}} \geq d_{\text{original}}\)
The qubit overhead is \(O(|V| \cdot R_G^c)\) where \(R_G^c\) is the sparsification depth
No proof needed for remarks.
A path in the graph connecting two vertices is a structure consisting of:
A start vertex \(\texttt{start} : V\)
An endpoint vertex \(\texttt{endpoint} : V\)
A list of edges \(\texttt{edges}\) forming the path
A proof that all edges are valid graph edges: for all \(e \in \texttt{edges}\), we have \(e \in G.\text{edgeSet}\)
The length of a path \(p\) is the number of edges in the path:
The trivial path at a vertex \(v\) is the path with:
\(\texttt{start} = v\)
\(\texttt{endpoint} = v\)
\(\texttt{edges} = []\) (empty list)
This path has length \(0\).
For any vertex \(v\), the trivial path at \(v\) has length \(0\):
This holds by reflexivity, since the trivial path has an empty edge list.
For any vertex \(v\), the trivial path at \(v\) starts at \(v\):
This holds by reflexivity from the definition of the trivial path.
For any vertex \(v\), the trivial path at \(v\) ends at \(v\):
This holds by reflexivity from the definition of the trivial path.
The short deforming paths property for a graph \(G\), a \(Z\)-support function \(\text{zSupport} : \mathbb {N} \to \text{Finset}(V)\), and a bound \(\kappa \in \mathbb {N}\), is the proposition:
This captures the desideratum: “for each check \(s_j\) with \(\mathcal{S}_{Z,j} \cap V \neq \emptyset \), there exists a path \(\gamma _j \subseteq E\) with \(|\gamma _j| \leq \kappa \).”
The short paths property is preserved under increasing the bound: if \(\kappa \leq \kappa '\) and \(G\) satisfies the short paths property with bound \(\kappa \), then \(G\) satisfies the short paths property with bound \(\kappa '\).
Let \(j \in \mathbb {N}\) and \(u, v \in V\) with \(u \in \text{zSupport}(j)\) and \(v \in \text{zSupport}(j)\). By the hypothesis, we obtain a path \(p\) with \(\text{start}(p) = u\), \(\text{endpoint}(p) = v\), and \(\text{length}(p) \leq \kappa \). Since \(\kappa \leq \kappa '\), by transitivity of \(\leq \) on natural numbers, we have \(\text{length}(p) \leq \kappa '\). Thus the same path \(p\) witnesses the property for \(\kappa '\).
For any vertex \(v\) in a graph \(G\), there exists a path of length \(0\) from \(v\) to itself:
The trivial path at \(v\) satisfies all three conditions by definition.
The sufficient expansion property for a graph \(G\) is the proposition:
where \(h(G)\) is the Cheeger constant of the graph.
If a graph \(G\) satisfies the sufficient expansion property, then its Cheeger constant is positive:
We compute: \(0 {\lt} 1 \leq h(G)\) by numerical computation and the hypothesis.
If a graph \(G\) satisfies the sufficient expansion property, then \(G\) is an expander graph.
Unfolding the definition of expander graph, we need to exhibit a constant \(\varepsilon {\gt} 0\) such that \(h(G) \geq \varepsilon \). We take \(\varepsilon = 1\). By numerical computation \(1 {\gt} 0\), and by hypothesis \(h(G) \geq 1\).
The low-weight cycle basis property for a graph \(G\) with bound \(W \in \mathbb {N}\) is the proposition:
All generating cycles have weight (number of vertices) bounded by \(W\).
The low-weight cycle basis property is preserved under increasing the bound: if \(W \leq W'\) and \(G\) satisfies the property with bound \(W\), then \(G\) satisfies the property with bound \(W'\).
Let \(c\) be any cycle index. By hypothesis, \(|\text{cycleVertices}(c)| \leq W\). Since \(W \leq W'\), by transitivity we have \(|\text{cycleVertices}(c)| \leq W'\).
If \(G\) satisfies the low-weight cycle basis property with bound \(W\), then the total cycle weight is bounded:
We compute:
The first inequality follows from the hypothesis applied to each cycle, and the second equality follows by simplification of a constant sum.
The deformed code parameters structure contains:
\(\Delta \): Graph degree (degree of gauging graph)
\(w\): Original check weight bound
\(\kappa \): Path length bound (from desideratum i)
\(W\): Cycle weight bound (from desideratum iii)
\(c\): Maximum cycles per edge (cycle degree)
The Gauss law operator weight is \(\Delta + 1\) (vertex plus incident edges).
The flux operator weight bound is \(W\) (from the cycle weight bound).
The deformed check weight bound is \(w + \kappa \) (original weight plus path contribution).
The maximum check weight across all generator types is:
The maximum qubit degree is:
where:
\(2\Delta ^\kappa \cdot w\) comes from paths through edges in layer 0
\(c\) comes from cycle participation
\(2\) comes from Gauss law at endpoints
For any deformed code parameters \(p\):
Unfolding the definition of maxCheckWeight, the Gauss law weight \(\Delta + 1\) is the left argument of the outer max, so it is at most the maximum.
For any deformed code parameters \(p\):
We compute: \(\text{fluxWeight}(p) = W \leq \max (W, w+\kappa ) \leq \max (\Delta +1, \max (W, w+\kappa )) = \text{maxCheckWeight}(p)\).
For any deformed code parameters \(p\):
We compute: \(\text{deformedCheckWeight}(p) = w + \kappa \leq \max (W, w+\kappa ) \leq \max (\Delta +1, \max (W, w+\kappa )) = \text{maxCheckWeight}(p)\).
For any deformed code parameters \(p\), all generator weights are bounded by the maximum check weight:
This follows directly from the three theorems: gaussLaw_le_maxCheckWeight, flux_le_maxCheckWeight, and deformedCheck_le_maxCheckWeight.
Given desiderata parameters \(\Delta \), \(w\), \(\kappa \), \(W\), and \(c\), the LDPC bounds are computed as:
The first component is the check weight bound, and the second is the qubit degree bound.
The check weight bound is given by:
This holds by reflexivity from the definition.
The qubit degree bound is given by:
This holds by reflexivity from the definition.
A valid Cheeger subset \(S \subseteq V\) is a subset satisfying:
\(S\) is nonempty
\(2|S| \leq |V|\)
If the Cheeger constant \(h(G) \geq 1\) (sufficient expansion property), then for any valid Cheeger subset \(S\):
where \(\delta (S)\) is the edge boundary of \(S\).
Unfold the definitions of SufficientExpansionProperty and ValidCheegerSubset. By the edge boundary bound from the Cheeger constant definition (edgeBoundary_ge_cheeger_mul_card), we have:
Since \(|S| {\gt} 0\) (from nonemptiness), we have \((|S| : \mathbb {Q}) {\gt} 0\). From \(h(G) \geq 1\) and positivity of \(|S|\):
Combining these inequalities: \((\text{edgeBoundaryCard}(G, S) : \mathbb {Q}) \geq |S|\). Converting from \(\mathbb {Q}\) to \(\mathbb {N}\) completes the proof.
The property that distance is preserved from \(d_{\text{original}}\) to \(d_{\text{deformed}}\) is:
Distance preservation is reflexive: for any \(d\), we have \(d \geq d\).
This follows from \(\leq \) being reflexive on natural numbers.
Distance preservation is transitive: if \(d_2 \geq d_1\) and \(d_3 \geq d_2\), then \(d_3 \geq d_1\).
Unfold the definition of DistancePreserved. The result follows by transitivity of \(\leq \) on natural numbers.
If \(G\) satisfies the sufficient expansion property (\(h(G) \geq 1\)), then for all valid Cheeger subsets \(S\):
This captures that expansion prevents weight reduction: any “shortcut” through the gauging graph would require crossing the boundary \(\delta (S)\), and \(|\delta (S)| \geq |S|\) means we cannot save on weight.
This follows directly from the theorem cheeger_ge_one_implies_boundary_ge_size.
The qubit overhead for a gauging graph with \(|V|\) vertices and sparsification depth \(R\) is:
The overhead is linear in \(V\) and \(R\):
Unfolding the definition: \(V \cdot (R + 1) = V \cdot R + V\) by ring arithmetic.
The overhead is monotone in \(V\): if \(V \leq V'\), then \(\text{qubitOverhead}(V, R) \leq \text{qubitOverhead}(V', R)\).
Unfolding the definition, we need \(V \cdot (R+1) \leq V' \cdot (R+1)\). This follows from \(V \leq V'\) and monotonicity of multiplication on the right.
The overhead is monotone in \(R\): if \(R \leq R'\), then \(\text{qubitOverhead}(V, R) \leq \text{qubitOverhead}(V, R')\).
Unfolding the definition, we need \(V \cdot (R+1) \leq V \cdot (R'+1)\). Since \(R \leq R'\), we have \(R+1 \leq R'+1\), and the result follows by monotonicity of multiplication on the left.
The total number of qubits is the original count plus the overhead:
The total qubit count formula:
This holds by reflexivity from the definitions.
The constant degree property for a graph \(G\) with bound \(\Delta \) is the proposition that all vertices have degree at most \(\Delta \):
The constant degree property is preserved under increasing the bound: if \(\Delta \leq \Delta '\) and \(G\) satisfies the property with bound \(\Delta \), then \(G\) satisfies the property with bound \(\Delta '\).
Let \(v\) be any vertex. By hypothesis, \(\deg (v) \leq \Delta \). Since \(\Delta \leq \Delta '\), by transitivity we have \(\deg (v) \leq \Delta '\).
The property that all desiderata are satisfied for a graph \(G\), \(Z\)-support function, and parameters \(\kappa \), \(W\), \(\Delta \) is:
When all desiderata are satisfied for parameters \(\kappa \), \(W\), \(\Delta \), and given original check weight \(w\) and cycle degree \(c\), let \(p\) be the corresponding DeformedCodeParams. Then:
All check weights are bounded by maxCheckWeight(\(p\))
All cycle weights are bounded by \(W\)
The expansion property holds: for all valid Cheeger subsets \(S\), \(|\delta (S)| \geq |S|\)
Decompose the hypothesis into its four components: short paths, sufficient expansion, low-weight cycles, and constant degree. Let \(p\) be the DeformedCodeParams structure.
The check weight bounds follow from gaussLaw_le_maxCheckWeight, flux_le_maxCheckWeight, and deformedCheck_le_maxCheckWeight for \(p\).
The cycle weight bound follows directly from the low-weight cycle basis hypothesis.
The expansion property follows from expansion_prevents_weight_reduction applied to the sufficient expansion hypothesis.
If all desiderata are satisfied, then the graph is an expander.
Decompose the hypothesis to extract the sufficient expansion property. Then apply expansion_implies_expander.
The edge degree formula satisfies:
This holds by ring arithmetic.
When \(\Delta = 0\) and \(\kappa {\gt} 0\), the edge degree contribution is \(0\):
Since \(\kappa {\gt} 0\), we have \(\kappa \neq 0\). Therefore \(0^\kappa = 0\), and simplification gives \(2 \cdot 0 \cdot w = 0\).
The overhead formula simplifies as:
This holds by ring arithmetic.
[Worst-Case Graph Construction]
Given an X-type logical operator \(L\) with weight \(W = |\mathcal{L}|\), the following construction produces a gauging graph \(G\) satisfying all desiderata with \(O(W \log ^2 W)\) auxiliary qubits:
Step 1 (Matching edges): For each check \(s_j\) whose Z-support overlaps \(\mathcal{L}\), pick a \(\mathbb {Z}_2\)-perfect-matching of the vertices in \(\mathcal{S}_{Z,j} \cap \mathcal{L}\). Add an edge to \(G\) for each matched pair. This ensures deforming paths have length 1 within each check’s Z-support.
Step 2 (Expansion edges): Add edges to \(G\) until \(h(G) \geq 1\). This can be done by:
Adding edges randomly while maintaining constant degree, or
Adding edges from a known constant-degree expander graph on \(W\) vertices
Let \(G_0\) denote the graph after Steps 1–2.
Step 3 (Cycle sparsification): Apply the Freedman–Hastings decongestion procedure:
Add \(R = O(\log ^2 W)\) layers of dummy vertices (copies of \(G_0\))
Connect consecutive layers with inter-layer edges
Cellulate long cycles to achieve constant cycle-degree
Result: The final graph \(\bar{\bar{G}}\) has:
\(|V| = O(W \log ^2 W)\) vertices (including dummies)
\(|E| = O(W \log ^2 W)\) edges
Cheeger constant \(h(\bar{\bar{G}}) \geq h(G_0) \geq 1\)
All cycles have constant weight after cellulation
The specification captures what the worst-case construction must produce: a gauging graph satisfying all desiderata with \(O(W \log ^2 W)\) overhead.
No proof needed for remarks.
A matched pair of vertices (representing an edge from the matching) consists of:
A first vertex \(v_1\)
A second vertex \(v_2\)
A proof that \(v_1 \neq v_2\)
The Step 1 matching data records the matched pairs from \(\mathbb {Z}_2\)-perfect matchings of each check’s Z-support. It consists of:
\(W\): the number of vertices in the logical support
A vertex type with finiteness and decidable equality
A proof that \(|V| = W\)
A finite set of matched pairs
A proof that all matched pairs consist of distinct vertices
Given Step 1 matching data \(M\), the matching graph \(G_{\text{match}}\) is the simple graph on the vertex set \(M.V\) where two vertices \(v\) and \(w\) are adjacent if and only if:
\(v \neq w\), and
\((v, w) \in M.\text{matchedPairs}\) or \((w, v) \in M.\text{matchedPairs}\)
A simple path in a graph \(G\) on vertices \(V\) consists of:
A non-empty list of vertices
A proof that consecutive vertices in the list are adjacent in \(G\)
The length of a path \(p\) is defined as the number of vertices in the path minus one:
This equals the number of edges in the path.
For a path \(p\):
The start is the first vertex in the list
The endpoint is the last vertex in the list
Given two adjacent vertices \(v\) and \(w\) in \(G\), the single-edge path from \(v\) to \(w\) is the path with vertex list \([v, w]\).
A single-edge path has length exactly 1.
By definition, the single-edge path has vertex list \([v, w]\) of length 2. The path length is \(2 - 1 = 1\).
A single-edge path from \(v\) to \(w\) starts at \(v\).
By definition, the vertex list is \([v, w]\), and the start is the head of this list, which is \(v\).
A single-edge path from \(v\) to \(w\) ends at \(w\).
By definition, the vertex list is \([v, w]\), and the endpoint is the last element of this list, which is \(w\).
For any matched pair \((v, w) \in M.\text{matchedPairs}\), there exists a path in the matching graph from \(v\) to \(w\) with length exactly 1.
Let \((v, w)\) be a matched pair. We first show that \(v\) and \(w\) are adjacent in the matching graph. By the definition of the matching graph, we need \(v \neq w\) (which follows from the matched_distinct property of \(M\)) and that \((v, w) \in M.\text{matchedPairs}\) (which is given). Thus \(v\) and \(w\) are adjacent.
We construct the single-edge path from \(v\) to \(w\) using SimplePath.ofEdge. By the lemmas on single-edge paths, this path starts at \(v\), ends at \(w\), and has length exactly 1.
For any matched pair \((v, w) \in M.\text{matchedPairs}\), the vertices \(v\) and \(w\) are adjacent in the matching graph.
By the definition of the matching graph, two vertices are adjacent if they are distinct and form a matched pair. Since \((v, w) \in M.\text{matchedPairs}\), the matched_distinct property ensures \(v \neq w\), and the membership condition is satisfied by hypothesis.
Let \(M\) be Step 1 matching data and let \(\text{zSupport} : \mathbb {N} \to \text{Finset}(V)\) be a function mapping check indices to their Z-support vertices. If for every check \(j\) and any two distinct vertices \(v, w\) in \(\text{zSupport}(j)\), we have \((v, w) \in M.\text{matchedPairs}\) or \((w, v) \in M.\text{matchedPairs}\), then for all \(j\) and all \(v, w \in \text{zSupport}(j)\), there exists a path from \(v\) to \(w\) with length at most 1.
Let \(j\) be a check index and let \(v, w \in \text{zSupport}(j)\). We consider two cases:
Case 1: \(v = w\). We construct the trivial path with vertex list \([v]\). This path has length \(1 - 1 = 0 \leq 1\).
Case 2: \(v \neq w\). By hypothesis, either \((v, w) \in M.\text{matchedPairs}\) or \((w, v) \in M.\text{matchedPairs}\). In the first case, \(v\) and \(w\) are adjacent in the matching graph by Lemma 793, so we construct the single-edge path from \(v\) to \(w\) with length exactly 1. In the second case, \((w, v)\) being a matched pair means \(w\) and \(v\) are adjacent, and by symmetry of the adjacency relation, \(v\) and \(w\) are adjacent, so again we construct the single-edge path with length 1.
The expander existence specification states: for any \(W \geq 2\), there exists a BaseGraphWithCycles \(G\) such that:
\(|V(G)| = W\)
There exists a constant \(d\) such that every vertex has degree at most \(d\)
\(G\) satisfies the sufficient expansion property (Cheeger constant \(\geq 1\))
Note: This is a cited result from random graph theory and explicit expander constructions (Ramanujan graphs, Margulis graphs).
Given \(W\) base vertices and \(R\) additional layers, the total vertex count is:
The vertex count expands as:
By ring arithmetic: \(W \cdot (R + 1) = W \cdot R + W \cdot 1 = W \cdot R + W\).
For any \(W\) and \(R\):
We have \(W \cdot (R + 1) \geq W \cdot 1 = W\) since \(R + 1 \geq 1\).
For any \(W\) and \(R_1 \leq R_2\):
Since \(R_1 \leq R_2\), we have \(R_1 + 1 \leq R_2 +1\), and thus \(W \cdot (R_1 + 1) \leq W \cdot (R_2 + 1)\).
Given \(R \leq (\log _2 W)^2 + 1\), the vertex count satisfies:
By the hypothesis \(R \leq (\log _2 W)^2 + 1\), we have \(R + 1 \leq (\log _2 W)^2 + 2\). Thus:
The Freedman–Hastings bound specification states: there exists a constant \(C\) such that for any constant-degree graph \(G\) (where every vertex has degree at most \(d\)), there exists \(R\) satisfying:
\(R \leq C \cdot (\log _2 |V(G)|)^2 + C\)
The sparsification exists with \(R\) layers and target cycle-degree 3
Note: This is a cited result requiring topological methods beyond this formalization.
The Cheeger preservation specification states: for any graph \(G_0\) with Cheeger constant \(h(G_0) \geq h_0\), and any number of layers \(R\), there exists a final graph \(G_{\text{final}}\) such that:
\(|V(G_{\text{final}})| \leq |V(G_0)| \cdot (R + 1)\)
\(h(G_{\text{final}}) \geq h_0\)
Note: This is a cited property of the Freedman–Hastings construction.
Each triangle has exactly 3 edges:
The triangle edge count equals 3.
This holds by reflexivity (definitional equality).
Triangulating an \(n\)-gon (with \(n \geq 3\)) produces exactly \(n - 2\) triangles, and \(n - 2 \geq 1\).
Since \(n \geq 3\), we have \(n - 2 \geq 1\). The count \(n - 2\) follows from the standard triangulation formula for convex polygons.
For any \(n \geq 3\), triangulation produces generating cycles each with weight exactly 3.
This holds by reflexivity: each triangle has 3 edges by definition.
The external results needed for the construction consist of:
Expander existence: expanders with \(h \geq 1\) exist for any \(W \geq 2\)
Freedman–Hastings bound: the F-H procedure gives \(R \leq O(\log ^2 W)\)
Cheeger preservation: the F-H procedure preserves the Cheeger constant
Given external results and \(W \geq 2\), the construction conditional claim is the proposition that there exists a BaseGraphWithCycles \(G\) satisfying:
Vertex bound: \(|V(G)| \leq W \cdot ((\log _2 W)^2 + 2)\)
Sufficient expansion: \(h(G) \geq 1\)
Low-weight cycles: all generating cycles have weight \(\leq 3\)
The conditional claim is well-formed and captures the following:
The sufficient expansion property implies Cheeger constant \(\geq 1\)
The low-weight cycle basis property with bound 3 implies all cycles have length \(\leq 3\)
The overhead arithmetic connects correctly: if \(R \leq (\log _2 W)^2 + 1\), then \(\text{vertexCountFromLayers}(W, R) \leq W \cdot ((\log _2 W)^2 + 2)\)
We verify each part:
For the expansion property: let \(G\) be a graph satisfying the sufficient expansion property. By definition, this means \(h(G) \geq 1\), which is exactly what we needed.
For the low-weight property: let \(G\) satisfy the low-weight cycle basis property with bound 3. By definition, for any cycle \(c\), the cycle length is at most 3.
For the overhead arithmetic: this follows directly from Theorem 800.
Step 1 achieves path bound \(\kappa = 1\): for any matched pair, there exists a path of length exactly 1.
This follows directly from Theorem 792.
If \(R \leq (\log _2 W)^2 + 1\), then \(\text{vertexCountFromLayers}(W, R) \leq W \cdot ((\log _2 W)^2 + 2)\).
This follows directly from Theorem 800.
The triangle edge count equals 3.
This holds by reflexivity (definitional equality).
For \(W \geq 4\), the overhead hierarchy holds:
This follows directly from the overhead hierarchy theorem.
A concrete example of Step 1 matching data with:
\(W = 2\) vertices
Vertex type \(\text{Fin}(2) = \{ 0, 1\} \)
Matched pairs: \(\{ (0, 1)\} \)
In the example matching data, there exists a path from vertex 0 to vertex 1 with length exactly 1.
We verify that \((0, 1) \in \text{exampleMatchingData.matchedPairs}\) by simplification (it is the unique element of the singleton set). Then we apply Theorem 792 to obtain the desired path.
For any Step 1 matching data \(M\), any \(W \geq 4\), and any \(R \leq (\log _2 W)^2 + 1\), the following are all satisfied:
For all matched pairs \(p \in M.\text{matchedPairs}\), there exists a path from \(p.1\) to \(p.2\) with length exactly 1
\(\text{vertexCountFromLayers}(W, R) \leq W \cdot ((\log _2 W)^2 + 2)\)
\(\text{triangleEdgeCount} = 3\)
\(\text{overheadBoundFunc}(\text{structured}, W) \leq \text{overheadBoundFunc}(\text{expander}, W)\)
We verify each part:
Let \(p \in M.\text{matchedPairs}\). By Theorem 792, there exists a path from \(p.1\) to \(p.2\) with length exactly 1.
This follows directly from Theorem 800 applied to \(W\), \(R\), and the hypothesis \(R \leq (\log _2 W)^2 + 1\).
This holds by reflexivity from the definition of triangleEdgeCount.
This follows from the first component of the overhead hierarchy theorem applied with the hypothesis \(W \geq 4\).
A measurement configuration for a stabilizer code \(C\) and an \(X\)-type logical operator \(L\) consists of:
A flux configuration (which includes the gauging graph and cycles),
A root vertex \(v_0 \in V\) for the path-based correction procedure.
A measurement outcome for a single Gauss law operator is an element of \(\mathbb {Z}/2\mathbb {Z}\), where \(0\) represents \(+1\) and \(1\) represents \(-1\).
The function outcomeToSign converts a measurement outcome \(\varepsilon \in \mathbb {Z}/2\mathbb {Z}\) to an integer sign:
The collection of all Gauss law measurement outcomes for a measurement configuration \(M\) consists of an outcome \(\varepsilon _v \in \{ 0, 1\} \) for each vertex \(v\), where \(0\) represents \(+1\) and \(1\) represents \(-1\).
The collection of all edge (flux) measurement outcomes for a measurement configuration \(M\) consists of an outcome \(\omega _e \in \{ 0, 1\} \) for each edge \(e\), where \(0\) represents \(+1\) and \(1\) represents \(-1\).
A 0-chain (or vertex chain) is a function from vertices to \(\mathbb {Z}/2\mathbb {Z}\).
A 1-chain (or edge chain) is a function from edges to \(\mathbb {Z}/2\mathbb {Z}\).
The zero 0-chain is the function that maps every vertex to \(0\).
The all-ones 0-chain \(\mathbf{1}_V\) is the function that maps every vertex to \(1\).
The coboundary map \(\delta _0: C_0 \to C_1\) is defined by: for a 0-chain \(c\) and an edge \(e = \{ v, w\} \),
The coboundary of the zero chain is zero: \(\delta _0(0) = 0\).
By extensionality, it suffices to show equality for an arbitrary edge \(e\). By simplification using the definitions of \(\delta _0\) and the zero vertex chain, we have \(\delta _0(0)(e) = 0 + 0 = 0\). We apply induction on the symmetric pair representation of \(e\), and by the lifting property, the result follows.
The coboundary of the all-ones chain is zero: \(\delta _0(\mathbf{1}_V) = 0\). This follows because \(1 + 1 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
By extensionality, it suffices to show equality for an arbitrary edge \(e\). By simplification using the definition of \(\delta _0\) and the all-ones vertex chain, we have \(\delta _0(\mathbf{1}_V)(e) = 1 + 1\). Since \((1 : \mathbb {Z}/2\mathbb {Z}) + 1 = 0\) (verified by computation), the result follows by applying induction on the symmetric pair representation and the lifting property.
If \(c\) is in \(\ker (\delta _0)\), then \(c\) is constant on adjacent vertices. That is, if \(\delta _0(c) = 0\) and \(v \sim w\), then \(c(v) = c(w)\).
Let \(v\) and \(w\) be adjacent vertices. From the hypothesis that \(\delta _0(c) = 0\), we obtain \(c(v) + c(w) = 0\) by evaluating at the edge \(\{ v, w\} \). We then calculate:
where we use the fact that \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
If \(c\) is in \(\ker (\delta _0)\), then \(c\) is constant on any connected path. That is, if \(\delta _0(c) = 0\) and there exists a path from \(v\) to \(w\), then \(c(v) = c(w)\).
From the reachability hypothesis, we obtain a path \(p\) from \(v\) to \(w\). We proceed by induction on the path. For the base case (nil path), the result holds by reflexivity. For the inductive step, where the path extends by an edge via adjacency, we apply Theorem 829 to get \(c\) is constant on the adjacent vertices, and then apply the induction hypothesis.
For a connected graph, \(\ker (\delta _0) = \{ 0, \mathbf{1}_V\} \). If \(\delta _0(c) = 0\), then \(c\) is either the zero chain or the all-ones chain.
First, we establish that \(c\) is constant on all vertices: for any \(v, w\), since the graph is connected, there exists a path from \(v\) to \(w\), and by Theorem 830, \(c(v) = c(w)\).
We consider two cases based on the value at the root vertex. If \(c(\text{root}) = 0\), then by constancy, \(c(v) = 0\) for all \(v\), so \(c\) is the zero chain. If \(c(\text{root}) \neq 0\), then since \((c(\text{root})).\text{val} \in \{ 0, 1\} \) (as elements of \(\mathbb {Z}/2\mathbb {Z}\) have values less than 2), and the case \(c(\text{root}) = 0\) is excluded, we must have \((c(\text{root})).\text{val} = 1\), so \(c(\text{root}) = 1\), and by constancy, \(c(v) = 1\) for all \(v\), so \(c\) is the all-ones chain.
The sum of 0-chains \(c_1 + c_2\) is defined pointwise: \((c_1 + c_2)(v) = c_1(v) + c_2(v)\).
The coboundary map \(\delta _0\) is additive: \(\delta _0(c_1 + c_2) = \delta _0(c_1) + \delta _0(c_2)\).
By extensionality, it suffices to show equality for an arbitrary edge \(e\). Using the definitions, we apply induction on the symmetric pair representation of \(e\). By the lifting property, for \(e = \{ v, w\} \):
by ring arithmetic.
If \(c\) and \(c'\) both satisfy \(\delta _0(c) = z\) and \(\delta _0(c') = z\), then \(c - c' \in \ker (\delta _0)\).
By extensionality, it suffices to show equality for an arbitrary edge \(e\). Using the definitions and applying induction on the symmetric pair representation, for \(e = \{ v, w\} \), we note that \(-x = x\) in \(\mathbb {Z}/2\mathbb {Z}\). Then:
where the last equality uses that \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
For a connected graph \(G\), if \(c_0\) satisfies \(\delta _0(c_0) = z\), then any \(c\) with \(\delta _0(c) = z\) is either \(c_0\) or \(c_0 + \mathbf{1}_V\).
By Theorem 834, the difference \(c - c_0\) is in \(\ker (\delta _0)\). Since \(-x = x\) in \(\mathbb {Z}/2\mathbb {Z}\), we have \(\delta _0(c + c_0) = 0\). By Theorem 831, \(c + c_0\) equals either the zero chain or the all-ones chain.
Case 1: If \(c + c_0 = 0\), then for each vertex \(v\), we have \(c(v) + c_0(v) = 0\). Using \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), we calculate:
So \(c = c_0\).
Case 2: If \(c + c_0 = \mathbf{1}_V\), then for each vertex \(v\), we have \(c(v) + c_0(v) = 1\). By similar calculation:
So \(c = c_0 + \mathbf{1}_V\).
The product of all Gauss law measurement outcomes is defined as
representing \(\sigma = \prod _v \varepsilon _v\) in multiplicative notation.
The logical measurement result is \(\sigma = \sum _v \varepsilon _v\) in \(\mathbb {Z}/2\mathbb {Z}\).
The sign function \(\varepsilon (c)\) for a 0-chain \(c\) and outcomes \((\varepsilon _v)\) is defined as
representing \(\prod _v \varepsilon _v^{c_v}\) in multiplicative notation.
The sign of the zero chain is zero: \(\varepsilon (0) = 0\) (representing the identity element, i.e., \(+1\)).
By simplification using the definitions of signOfChain and zeroVertexChain, each term \(\varepsilon _v \cdot 0 = 0\), so the sum is \(0\).
The sign of the all-ones chain equals the logical result: \(\varepsilon (\mathbf{1}_V) = \sigma \).
By simplification using the definitions, each term \(\varepsilon _v \cdot 1 = \varepsilon _v\), so \(\varepsilon (\mathbf{1}_V) = \sum _v \varepsilon _v = \sigma \).
The sign function is additive: \(\varepsilon (c_1 + c_2) = \varepsilon (c_1) + \varepsilon (c_2)\).
By the definition of signOfChain and addVertexChain, and distributing the sum, we have:
by ring arithmetic and distributivity of finite sums.
For any 0-chain \(c_0\), the sum of signs over the cocycle fiber equals \(\sigma \):
This is the algebraic heart of the gauging measurement theorem.
By Theorem 841, \(\varepsilon (c_0 + \mathbf{1}_V) = \varepsilon (c_0) + \varepsilon (\mathbf{1}_V)\). By Theorem 840, \(\varepsilon (\mathbf{1}_V) = \sigma \). Then:
where we use that \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
The identity term (\(c = 0\)) in the projector expansion satisfies: \(\varepsilon (0) = 0\), all vertex values are 0, and \(\delta _0(0) = 0\).
The logical operator term (\(c = \mathbf{1}_V\)) in the projector expansion satisfies: \(\varepsilon (\mathbf{1}_V) = \sigma \), all vertex values are 1, and \(\delta _0(\mathbf{1}_V) = 0\).
After measuring \(Z_e\) with outcomes \(z = (z_e)\), the projection selects the cocycle fiber \(\{ c : \delta _0(c) = z\} \):
For the forward direction, if \(\delta _0(c) = z\), then for any edge \(e\), \(\delta _0(c)(e) = z(e)\) by function application. For the reverse direction, if \(\delta _0(c)(e) = z(e)\) for all \(e\), then by function extensionality, \(\delta _0(c) = z\).
The cocycle fiber for an edge chain \(z\) is the set
For connected graphs, the cocycle fiber has at most 2 elements: any third element equals one of the first two.
This follows directly from Theorem 835, which states that any element of the fiber \(\{ c : \delta _0(c) = z\} \) is either \(c_1\) or \(c_1 + \mathbf{1}_V\).
For connected \(G\), if \(c'\) satisfies \(\delta _0(c') = z\), then:
The sum of signs over the fiber equals \(\sigma \): \(\varepsilon (c') + \varepsilon (c' + \mathbf{1}_V) = \sigma \)
The second element also maps to \(z\): \(\delta _0(c' + \mathbf{1}_V) = z\)
The product of all Gauss law operators on vertex qubits gives the logical operator: \(\prod _v A_v\) has vertex support \(= 1\) at all vertices, which represents \(L\).
For each vertex \(v\), the result follows directly from Theorem 274.
The product of edge supports in \(\prod _v A_v\) is zero (edges cancel).
This follows directly from Theorem 275.
The path correction sum along a list of edges is defined as
The path sum of an empty path is 0.
This holds by reflexivity from the definition of pathSum.
The path sum of a singleton path \([e]\) equals the edge outcome \(\omega _e\).
By simplification using the definition of pathSum with a single-element list.
For any accumulator \(a\) and path:
We proceed by induction on the path with the accumulator generalized. For the empty path, both sides equal \(a\). For the inductive step with a path \(\text{hd} :: \text{tl}\), we apply the induction hypothesis to the tail with accumulator \(a + \omega _{\text{hd}}\), unfold the definition of pathSum, and use ring arithmetic.
Path sum is additive over concatenation:
We proceed by induction on \(p_1\). For the empty list, the result follows by simplification. For the inductive step with \(p_1 = \text{hd} :: \text{tl}\), we unfold pathSum, apply Theorem 854 twice, apply the induction hypothesis, and use ring arithmetic.
Path sum of a reversed list equals the original (since addition is commutative):
We proceed by induction on the path. For the empty list, the result holds by reflexivity. For the inductive step with \(\text{hd} :: \text{tl}\), we simplify \((\text{hd} :: \text{tl}).\text{reverse} = \text{tl}.\text{reverse} \mathbin {+\! \! +} [\text{hd}]\). By Theorem 855, we split the path sum. By the induction hypothesis, \(\text{pathSum}(\omega , \text{tl}.\text{reverse}) = \text{pathSum}(\omega , \text{tl})\). We then apply Theorem 854 and use ring arithmetic.
A valid path system assigns to each vertex a list of edges forming a path from the root, such that:
The path to the root is empty
Each edge in each path is an actual graph edge
The byproduct chain computed from edge outcomes via path sums is defined by
where \(\gamma _v\) is the path from the root to \(v\).
The byproduct chain is 0 at the root: \(c'(v_0) = 0\).
By simplification using the definitions of byproductChain, the valid path system property that the root path is empty, and Theorem 852.
For adjacent vertices \(v, w\) where the path to \(w\) extends the path to \(v\) by edge \(\{ v, w\} \):
This shows the path-based computation correctly recovers the edge outcome.
By the hypothesis that \(\gamma _w = \gamma _v \mathbin {+\! \! +} [\{ v, w\} ]\), we have:
using Theorem 855, Theorem 853, and \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
In a connected graph, paths from the root to all vertices exist.
This follows from the preconnectedness property of the connected graph.
Given any spanning tree path system, the byproduct chain \(c'\) computed from edge outcomes \(z\) satisfies:
The byproduct at root is 0
For every vertex \(v\), \(c'(v) = \text{pathSum}(\omega , \gamma _v)\)
The first part follows from Theorem 859. The second part holds by reflexivity from the definition of byproductChain.
Let \(M\) be a measurement configuration and let \((\varepsilon _v)\) be Gauss law measurement outcomes. Define \(\sigma = \sum _v \varepsilon _v \pmod{2}\). Then:
Part 1: \(\sigma \in \{ 0, 1\} \) representing measurement result \(\pm 1\).
Part 2: The Gauss law product gives the logical operator support: for all vertices \(v\), \(\text{productVertexSupport}(v) = 1\).
Part 3: The kernel of \(\delta _0\) has two elements \(\{ 0, \mathbf{1}_V\} \) for connected \(G\): if \(\delta _0(c) = 0\), then \(c = 0\) or \(c = \mathbf{1}_V\).
Part 4: Sum over the cocycle fiber gives the projector factor: for any \(c_0\),
Together, these establish that the gauging measurement procedure produces output state proportional to \((I + \sigma L)|\psi \rangle \), which is the projection of \(|\psi \rangle \) onto the \(\sigma \)-eigenspace of \(L\).
Part 1: Since \(\sigma \) is an element of \(\mathbb {Z}/2\mathbb {Z}\), its value is less than 2, so \(\sigma .\text{val} \in \{ 0, 1\} \). We consider both cases: if \(\sigma .\text{val} = 0\), then \(\sigma = 0\); if \(\sigma .\text{val} = 1\), then \(\sigma = 1\).
Part 2: This follows directly from Theorem 849.
Part 3: This follows directly from Theorem 831.
Part 4: This follows directly from Theorem 842.
The measurement outcome determines a valid \(\pm 1\) result:
We unfold the definition of outcomeToSign. If \(\sigma = 0\), then \(\text{outcomeToSign}(\sigma ) = +1\). If \(\sigma \neq 0\), then \(\text{outcomeToSign}(\sigma ) = -1\). By simplification, both cases give a valid \(\pm 1\) result.
The Gauss law operators commute (as \(X\)-type operators): for any vertices \(v, w\),
This follows directly from Theorem 267.
For any edge outcomes \(z\) and any \(c'\) with \(\delta _0(c') = z\):
The fiber \(\{ c : \delta _0(c) = z\} = \{ c', c' + \mathbf{1}_V\} \)
Sum of signs \(= \sigma \)
The all-ones vertex support represents \(L\)
Every measurement outcome \(\varepsilon \) satisfies \(\varepsilon = 0\) or \(\varepsilon = 1\).
By case analysis on the finite type \(\mathbb {Z}/2\mathbb {Z}\), which has exactly two elements.
If all measurement outcomes are \(+1\) (i.e., \(\varepsilon _v = 0\) for all \(v\)), then the logical result is \(+1\) (i.e., \(\sigma = 0\)).
We unfold the definition of productOfGaussOutcomes. Since \(\varepsilon _v = 0\) for all \(v\) by hypothesis, the sum \(\sum _v \varepsilon _v = \sum _v 0 = 0\).
The number of \(-1\) outcomes is the count of vertices \(v\) where \(\varepsilon _v = 1\).
The product of outcomes equals the count of \(-1\) outcomes modulo 2:
We prove by induction on finite sets that \(\sum _{v \in S} \varepsilon _v = |\{ v \in S : \varepsilon _v = 1\} |\) in \(\mathbb {Z}/2\mathbb {Z}\).
For the empty set, both sides are 0.
For the inductive step with \(S = \{ a\} \cup S'\) where \(a \notin S'\):
If \(\varepsilon _a = 1\): The filter over the new set includes \(a\), so the cardinality increases by 1. The sum also increases by 1, matching in \(\mathbb {Z}/2\mathbb {Z}\).
If \(\varepsilon _a = 0\) (by Lemma 867): The filter is unchanged, and the sum increases by 0.
Applying this to the universal set gives the result.
The flux constraint states that edge outcomes satisfy the cycle constraint: for all cycles \(c\) in the cycle basis,
Physical interpretation: \(|0\rangle _E\) is a \(+1\) eigenstate of all flux operators \(B_p\).
Two paths with the same endpoints differ by a cycle. If cycles have sum 0, the paths give equal correction values: if \(\text{pathSum}(\omega , p_1 \mathbin {+\! \! +} p_2^{\text{rev}}) = 0\), then \(\text{pathSum}(\omega , p_1) = \text{pathSum}(\omega , p_2)\).
By Theorem 855 and Theorem 856, we have:
Therefore:
using \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
1.9 Space Distance Bound
This section establishes the main distance bound for deformed codes: \(d^* \geq \min (h(G), 1) \cdot d\), where \(h(G)\) is the Cheeger constant of the gauging graph and \(d\) is the distance of the original code.
The weight of an operator on the deformed code is defined as
where \(P_{\text{orig}}\) is the original operator component and \(E_{\text{path}}\) is the edge path component.
The weight on original qubits only of a deformed operator \(\tilde{P}\) is
The weight on edge qubits only of a deformed operator \(\tilde{P}\) is
For any deformed operator \(\tilde{P}\),
This holds by reflexivity from the definition of deformed operator weight.
The Cheeger factor of a graph \(G\) is defined as
where \(h(G)\) is the Cheeger constant of \(G\).
For any graph \(G\), \(\chi (G) \leq 1\).
By the definition of the Cheeger factor as \(\min (h(G), 1)\), we have \(\chi (G) \leq 1\) by the property that \(\min (a, b) \leq b\).
For any graph \(G\), \(\chi (G) \leq h(G)\).
By the definition of the Cheeger factor as \(\min (h(G), 1)\), we have \(\chi (G) \leq h(G)\) by the property that \(\min (a, b) \leq a\).
For any graph \(G\), \(\chi (G) \geq 0\).
The Cheeger factor is \(\min (h(G), 1)\). Since \(h(G) \geq 0\) by Theorem 247 and \(1 {\gt} 0\), we have \(\chi (G) \geq 0\).
If \(h(G) \geq 1\), then \(\chi (G) = 1\).
When \(h(G) \geq 1\), we have \(\min (h(G), 1) = 1\) since \(1 \leq h(G)\).
If \(h(G) {\lt} 1\), then \(\chi (G) = h(G)\).
When \(h(G) {\lt} 1\), we have \(\min (h(G), 1) = h(G)\) since \(h(G) \leq 1\).
A logical operator on the deformed code \(L'\) consists of:
An underlying deformed operator
Gauss law commutation: For all vertices \(v\), the edge path boundary at \(v\) equals the target boundary at \(v\)
Flux commutation: For all cycles \(c\), the intersection of the edge path with cycle edges has even cardinality: \(|E_{\text{path}} \cap c| \equiv 0 \pmod{2}\)
Deformed check commutation: The original part commutes with all original code checks
Non-stabilizer: The original part is not a stabilizer element
The weight of a logical operator on the deformed code \(L'\) is defined as \(|L'| := |\tilde{P}|\) where \(\tilde{P}\) is the underlying deformed operator.
The X-support on vertex qubits of a deformed operator \(\tilde{P}\) is
The size of the X-support on vertex qubits is \(|S_X^V|\).
The boundary of an edge set \(S\) at vertex \(v\) counts incident edges modulo 2:
This is the boundary map \(\partial _1 : C_1(G; \mathbb {Z}_2) \to C_0(G; \mathbb {Z}_2)\).
An edge set \(S\) is a cocycle (has zero boundary) if \(\partial _1(S)(v) = 0\) for every vertex \(v\).
If an operator’s X-support \(S_X^E\) on edges has even degree at every vertex (i.e., each vertex is incident to an even number of edges in \(S_X^E\)), then \(S_X^E\) is a cocycle.
Mathematically: if for all vertices \(v\), \(|\{ e \in S_X^E : v \in e\} |\) is even, then \(\partial _1(S_X^E) = 0\).
Let \(v\) be an arbitrary vertex. By the definition of edge set boundary, \(\partial _1(S_X^E)(v) = |\{ e \in S_X^E : v \in e\} | \mod 2\). By the hypothesis that each vertex has even degree in \(S_X^E\), this cardinality is even, so \(\partial _1(S_X^E)(v) = 0\) in \(\mathbb {Z}_2\). Since \(v\) was arbitrary, \(S_X^E\) is a cocycle.
The coboundary of a vertex set \(S\) is the set of edges with exactly one endpoint in \(S\):
The size of the coboundary of a vertex set \(S\) is \(|\delta _0(S)|\).
The empty edge set is the coboundary of the empty vertex set: \(\emptyset = \delta _0(\emptyset )\).
We prove set equality by extensionality. Let \(e\) be an arbitrary edge. We show \(e \in \emptyset \Leftrightarrow e \in \delta _0(\emptyset )\). The left side is always false since \(\emptyset \) contains no elements. For the right side, \(e \in \delta _0(\emptyset )\) would require \(e\) to have exactly one endpoint in \(\emptyset \), which is impossible since \(\emptyset \) contains no vertices. Thus both sides are false.
For an empty cocycle, we can always find a coboundary witness (the empty set).
This follows directly from Theorem 892.
\(\emptyset = \delta _0(\emptyset )\).
By extensionality, we show no edge belongs to either set. An edge \(e\) is not in \(\emptyset \) trivially. An edge \(e\) is not in \(\delta _0(\emptyset )\) since having exactly one endpoint in \(\emptyset \) is impossible: if \(e = \{ v, w\} \), then either \(v \in \emptyset \) or \(w \in \emptyset \) (or both, or neither), but \(\emptyset \) contains no elements, so neither \(v \in \emptyset \) nor \(w \in \emptyset \), contradicting the requirement of having exactly one endpoint in \(\emptyset \).
The vertex X-support of the equivalent logical after multiplying by Gauss laws is \(S_X^V \oplus \tilde{S}_X^V\) (symmetric difference).
After multiplying by appropriate Gauss law operators, the edge X-support is eliminated. Specifically, if \(S_X^E = \delta _0(\tilde{S})\) for some vertex set \(\tilde{S}\), then
Since \(S_X^E = \delta _0(\tilde{S})\) by hypothesis, we have \(S_X^E \oplus \delta _0(\tilde{S}) = \delta _0(\tilde{S}) \oplus \delta _0(\tilde{S}) = \emptyset \) by the property that symmetric difference of a set with itself is empty.
The restriction of a deformed operator to original qubits is simply the original operator component \(P_{\text{orig}}\).
For a deformed logical operator \(L'\), its restriction to original qubits commutes with all original code checks.
Let \(i\) be any check index. By the definition of DeformedLogicalOperator, the condition commutes_deformed_checks ensures that for all \(j\), the original part commutes with the \(j\)-th check. Applying this directly gives the result.
For a deformed operator \(\tilde{P}\), \(|\text{restrictToOriginal}(\tilde{P})| = |P_{\text{orig}}|\).
This holds by reflexivity from the definition.
If a Pauli operator \(P\) commutes with the original code \(C\) and is not a stabilizer element, and \(C\) has distance \(d\), then \(|P| \geq d\).
This follows directly from the definition of code distance: hasDistance C d states that any operator commuting with the code and not being a stabilizer has weight at least \(d\).
For a vertex set \(S\) satisfying the Cheeger validity condition \(|S| \leq |V|/2\), we have
This follows directly from Theorem 248.
For a valid Cheeger subset \(S\), the coboundary satisfies \(|\delta _0(S)| \geq h(G) \cdot |S|\).
The coboundary \(\delta _0(S)\) equals the edge boundary, which consists of edges with exactly one endpoint in \(S\). By definition, the coboundary cardinality equals the edge boundary cardinality. Applying Theorem 901 gives the result.
A distance configuration bundles:
A stabilizer code with distance \(d\)
An X-type logical operator
A deformed code configuration
The gauging graph from a distance configuration is the graph from its deformed code configuration.
Let \(\mathcal{C}\) be an \([[n, k, d]]\) stabilizer code and let \(G\) be a gauging graph. For any logical operator \(L'\) on the deformed code,
We proceed in several steps:
Step 1: From Theorem 898, the original operator part commutes with all original code checks.
Step 2: By Theorem 900, since the original part commutes with the code and is not a stabilizer element, we have \(|P_{\text{orig}}| \geq d\).
Step 3: The total weight satisfies \(|L'| \geq |P_{\text{orig}}|\) since \(|L'| = |P_{\text{orig}}| + |E_{\text{path}}|\) by definition.
Step 4: Chain the inequalities: \(|L'| \geq |P_{\text{orig}}| \geq d\).
Step 5: We consider two cases based on the Cheeger constant:
Case \(h(G) \geq 1\): By Theorem 881, \(\chi (G) = 1\), so \(\chi (G) \cdot d = d\) and \(|L'| \geq d = \chi (G) \cdot d\).
Case \(h(G) {\lt} 1\): By Theorem 882, \(\chi (G) = h(G)\). Since \(h(G) {\lt} 1\), we have \(h(G) \cdot d \leq 1 \cdot d = d\). Thus \(|L'| \geq d \geq h(G) \cdot d = \chi (G) \cdot d\).
If \(h(G) \geq 1\), then the deformed code distance satisfies \(d^* \geq d\).
If \(h(G) \geq 1\), then for any logical operator \(L'\) on the deformed code, \(|L'| \geq d\).
Apply Theorem 905 and use \(\chi (G) = 1\) when \(h(G) \geq 1\), giving \(|L'| \geq 1 \cdot d = d\).
The Cheeger constant of a sparsified graph \(\bar{\bar{G}}\) is the Cheeger constant of the sparsified graph with its cellulation assignment.
The sparsified Cheeger factor is \(\min (h(\bar{\bar{G}}), 1)\).
The sparsified Cheeger factor is non-negative: \(\chi (\bar{\bar{G}}) \geq 0\).
The sparsified Cheeger factor is \(\min (h(\bar{\bar{G}}), 1)\). Since the Cheeger constant is non-negative by Theorem 247 and \(1 {\gt} 0\), the minimum is also non-negative.
The sparsified Cheeger factor satisfies \(\chi (\bar{\bar{G}}) \leq 1\).
By the definition as \(\min (h(\bar{\bar{G}}), 1)\), we have \(\chi (\bar{\bar{G}}) \leq 1\).
For any deformed operator \(\tilde{P}\), \(|\tilde{P}| \geq 0\).
Natural numbers are non-negative.
For any deformed operator \(\tilde{P}\), \(|\tilde{P}|_V \leq |\tilde{P}|\).
Since \(|\tilde{P}| = |\tilde{P}|_V + |\tilde{P}|_E\) and \(|\tilde{P}|_E \geq 0\), we have \(|\tilde{P}|_V \leq |\tilde{P}|\) by integer arithmetic.
For any deformed operator \(\tilde{P}\), \(|\tilde{P}|_E \leq |\tilde{P}|\).
Since \(|\tilde{P}| = |\tilde{P}|_V + |\tilde{P}|_E\) and \(|\tilde{P}|_V \geq 0\), we have \(|\tilde{P}|_E \leq |\tilde{P}|\) by integer arithmetic.
If \(\chi (G) = 0\), then \(\chi (G) \cdot d = 0\).
By simplification using the hypothesis \(\chi (G) = 0\), we have \(0 \cdot d = 0\).
If \(d_1 \leq d_2\), then \(\chi (G) \cdot d_1 \leq \chi (G) \cdot d_2\).
Since \(\chi (G) \geq 0\) by Theorem 880 and \(d_1 \leq d_2\) by hypothesis, multiplying both sides by the non-negative \(\chi (G)\) preserves the inequality.
A gauging graph \(G\) satisfies the distance preservation desideratum if \(h(G) \geq 1\).
If \(G\) satisfies distance preservation, then \(\chi (G) = 1\).
This follows directly from Theorem 881 since \(h(G) \geq 1\).
A graph satisfies distance preservation if and only if \(h(G) \geq 1\).
This is definitionally true by reflexivity.
The explicit distance bound is defined as
If \(h \geq 1\), then \(d^*_{\min } \leq d\).
When \(h \geq 1\), we have \(\min (h, 1) = 1\), so \(d^*_{\min } = \lfloor 1 \cdot d \rfloor = \lfloor d \rfloor = d\). Thus \(d^*_{\min } \leq d\).
When \(h = 1\), \(d^*_{\min } = d\).
When \(h = 1\), we have \(\min (1, 1) = 1\), so \(d^*_{\min } = \lfloor 1 \cdot d \rfloor = \lfloor d \rfloor \). For natural number \(d\), \(\lfloor d \rfloor = d\).
When \(h \geq 1\), \(d^*_{\min } = d\).
When \(h \geq 1\), we have \(\min (h, 1) = 1\) since \(1 \leq h\). Thus \(d^*_{\min } = \lfloor 1 \cdot d \rfloor = \lfloor d \rfloor = d\) for natural number \(d\).
[Optimal Cheeger Constant]
Picking a graph with Cheeger constant \(h(G) = 1\) is optimal in the following sense:
Sufficient for distance preservation: If \(h(G) \geq 1\), then \(d^* \geq d\) by the space distance bound lemma.
Larger Cheeger doesn’t help: If \(h(G) {\gt} 1\), the distance bound is still \(d^* \geq d\) (not \(d^* \geq h(G) \cdot d\)). This is because logical operators can always be “cleaned” onto vertex qubits, where the original code distance applies.
Small Cheeger causes distance loss: If \(h(G) {\lt} 1\), the distance can be reduced by a factor of \(h(G)\). In the worst case, a logical operator of the deformed code has most of its weight on edges, and cleaning it onto vertices increases vertex weight by factor \(1/h(G)\).
The key insight is that the Cheeger factor \(\min (h(G), 1)\) captures exactly the distance preservation guarantee: it equals \(1\) when \(h(G) \geq 1\) (full preservation) and equals \(h(G)\) when \(h(G) {\lt} 1\) (distance reduction).
No proof needed for remarks.
Let \(G\) be a simple graph with Cheeger constant \(h(G) \geq 1\). Then the Cheeger factor \(\min (h(G), 1) = 1\).
This follows directly from the theorem that the Cheeger factor equals one when the Cheeger constant is at least one.
Let \(G\) be a simple graph with Cheeger constant \(h(G) {\lt} 1\). Then the Cheeger factor \(\min (h(G), 1) = h(G)\).
This follows directly from the theorem that the Cheeger factor equals the Cheeger constant when it is less than one.
Let \(G\) be a simple graph with Cheeger constant \(h(G) = 1\). Then the Cheeger factor is exactly \(1\).
We apply the theorem that the Cheeger factor equals one when \(h(G) \geq 1\). Since \(h(G) = 1\), we have \(h(G) \geq 1\), so the result follows.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\). If \(h(G) \geq 1\) where \(G\) is the gauging graph, then for any deformed logical operator \(L_{\mathrm{def}}\), we have \(\mathrm{weight}(L_{\mathrm{def}}) \geq d\).
This follows directly from the space distance bound without reduction corollary.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) satisfying the distance preservation property. Then for any deformed logical operator \(L_{\mathrm{def}}\), we have \(\mathrm{weight}(L_{\mathrm{def}}) \geq d\).
This is an equivalent formulation of the theorem that \(h(G) \geq 1\) preserves distance.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) and \(h(G) \geq 1\). Then for any deformed logical operator \(L_{\mathrm{def}}\), we have \(\mathrm{weight}(L_{\mathrm{def}}) \geq d\) as a rational inequality.
This follows by casting the natural number inequality from the distance preservation theorem to rationals.
For any graph \(G\) and distance \(d\), we have
We unfold the definition of the Cheeger factor and consider two cases. If \(h(G) {\lt} 1\), then \(\min (h(G), 1) = h(G)\), so \(\min (h(G), 1) \cdot d = h(G) \cdot d\). This is at most \(\min (h(G) \cdot d, d)\) since it equals the first component of the minimum. For the second component, we have \(h(G) \cdot d \leq d\) since \(h(G) {\lt} 1\) and \(d \geq 0\).
If \(h(G) \geq 1\), then \(\min (h(G), 1) = 1\), so \(\min (h(G), 1) \cdot d = d\). We verify both components: \(d = 1 \cdot d \leq h(G) \cdot d\) since \(h(G) \geq 1\), and \(d \leq d\) trivially.
Let \(G\) be a simple graph with Cheeger constant \(h(G) {\gt} 1\). Then for any \(d\),
Since \(h(G) {\gt} 1\), we have \(h(G) \geq 1\). By the theorem that the Cheeger factor equals one when \(h(G) \geq 1\), we have \(\min (h(G), 1) = 1\). Thus \(\min (h(G), 1) \cdot d = 1 \cdot d = d\) by ring arithmetic.
Let \(G\) be a simple graph with Cheeger constant \(h(G) = 2\). Then for any \(d\),
We apply the theorem that \(h(G) {\gt} 1\) gives no improvement. Since \(h(G) = 2 {\gt} 1\), the result follows.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) such that \(h(G) {\gt} 1\) for the gauging graph \(G\). Then \(\min (h(G), 1) \cdot d = d\).
This follows directly from the theorem that \(h(G) {\gt} 1\) gives no improvement.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) and \(L_{\mathrm{def}}\) a deformed logical operator. Then the original part of the deformed logical has weight \(\geq d\).
We apply the restriction weight theorem: the original part has weight at least \(d\) because it commutes with all original checks (from the commutation theorem) and is not a stabilizer element, so the original code distance bound applies.
Let \(G\) be a simple graph with Cheeger constant \(h(G) {\lt} 1\). Then for any \(d\),
By the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), we have \(\min (h(G), 1) = h(G)\), so the result follows.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) such that \(h(G) {\lt} 1\) for the gauging graph \(G\). Then for any deformed logical operator \(L_{\mathrm{def}}\),
We apply the space distance bound lemma to get \(\mathrm{weight}(L_{\mathrm{def}}) \geq \min (h(G), 1) \cdot d\). By the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), we substitute to obtain the result.
Let \(G\) be a simple graph with \(0 {\lt} h(G) {\lt} 1\) and let \(d {\gt} 0\). Then
By the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), we have \(\min (h(G), 1) = h(G)\). Since \(d {\gt} 0\), we have \(d \neq 0\), so by field simplification, \(\frac{h(G) \cdot d}{d} = h(G)\).
Let \(G\) be a simple graph with \(h(G) {\gt} 0\). If the edge weight \(w_e\) satisfies \(w_e \geq h(G) \cdot w_v\) for some vertex weight \(w_v\), then
We want to show \(\frac{w_e}{h(G)} \geq w_v\). Rearranging using \(h(G) {\gt} 0\), this is equivalent to \(w_e \geq h(G) \cdot w_v\), which is exactly the hypothesis \(h_{\mathrm{edge\_ bound}}\) after commuting the multiplication.
Let \(G\) be a simple graph with Cheeger constant \(h(G) = \frac{1}{2}\). Then for any \(d\),
Since \(h(G) = \frac{1}{2} {\lt} 1\), by the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), we have \(\min (h(G), 1) = \frac{1}{2}\). Thus \(\min (h(G), 1) \cdot d = \frac{1}{2} \cdot d = \frac{d}{2}\) by ring arithmetic.
For any simple graph \(G\), if \(h(G) = 1\) then the Cheeger factor is exactly \(1\).
Let \(G\) be arbitrary and assume \(h(G) = 1\). This follows directly from the Cheeger factor at threshold theorem.
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) such that \(h(G) = 1\) for the gauging graph \(G\). Then for any deformed logical operator \(L_{\mathrm{def}}\), we have \(\mathrm{weight}(L_{\mathrm{def}}) \geq d\).
We apply the theorem that \(h(G) \geq 1\) preserves distance. Since \(h(G) = 1 \geq 1\), the result follows.
Let \(G\) be a simple graph with \(h(G) {\lt} 1\). Then the Cheeger factor is also less than \(1\).
By the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), we have \(\min (h(G), 1) = h(G) {\lt} 1\).
Let \(G\) be a simple graph with \(h(G) {\gt} 1\). Then the Cheeger factor equals \(1\).
Since \(h(G) {\gt} 1\), we have \(h(G) \geq 1\). This follows directly from the theorem that the Cheeger factor equals one when \(h(G) \geq 1\).
For any simple graph \(G\),
We consider two cases. If \(h(G) \geq 1\), then by simplification and the theorem that the Cheeger factor equals one when \(h(G) \geq 1\), the result is \(1\). If \(h(G) {\lt} 1\), then by simplification (since the condition \(h(G) \geq 1\) is false) and the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), the result is \(h(G)\).
Let \((n, k, d)\) be code parameters with configuration \(\mathrm{cfg}\) and \(L_{\mathrm{def}}\) a deformed logical operator. Then
We apply the space distance bound lemma to get the bound with the Cheeger factor, then substitute using the Cheeger factor characterization.
Let \(G_1\) and \(G_2\) be simple graphs with \(h(G_1) = \frac{1}{2}\) and \(h(G_2) = 1\). Then for any \(d\),
Since \(h(G_1) = \frac{1}{2} {\lt} 1\), by the theorem for \(h {\lt} 1\), we have \(\min (h(G_1), 1) = \frac{1}{2}\). Since \(h(G_2) = 1 \geq 1\), by the theorem for \(h \geq 1\), we have \(\min (h(G_2), 1) = 1\). Thus \(\frac{1}{2} \cdot d \cdot 2 = d = 1 \cdot d\) by ring arithmetic.
Let \(G_1\) and \(G_2\) be simple graphs with \(h(G_1) = 1\) and \(h(G_2) = 2\). Then for any \(d\),
Since \(h(G_1) = 1 \geq 1\) and \(h(G_2) = 2 \geq 1\), by the theorem for \(h \geq 1\), both Cheeger factors equal \(1\). Thus both sides equal \(d\).
For any simple graph \(G\), we have \(0 \leq \min (h(G), 1) \leq 1\).
The lower bound follows from the non-negativity of the Cheeger factor, and the upper bound follows from the theorem that the Cheeger factor is at most one.
For any simple graph \(G\) and \(d \in \mathbb {N}\), we have \(\min (h(G), 1) \cdot d \geq 0\).
This follows by multiplying two non-negative quantities: the Cheeger factor is non-negative by the Cheeger factor non-negativity theorem, and \(d\) is a natural number cast to rationals, hence non-negative.
For any simple graph \(G\) and \(d \in \mathbb {N}\), we have \(\min (h(G), 1) \cdot d \leq d\).
We have \(\min (h(G), 1) \cdot d \leq 1 \cdot d\) by multiplying the inequality \(\min (h(G), 1) \leq 1\) (from the Cheeger factor upper bound theorem) by the non-negative quantity \(d\). Simplifying \(1 \cdot d = d\) gives the result.
Let \(G_1\) and \(G_2\) be simple graphs with \(h(G_1) \leq h(G_2)\). Then \(\min (h(G_1), 1) \leq \min (h(G_2), 1)\).
We unfold the definition of the Cheeger factor. The function \(\min (\cdot , 1)\) is monotonic, so \(h(G_1) \leq h(G_2)\) implies \(\min (h(G_1), 1) \leq \min (h(G_2), 1)\) by applying monotonicity of the minimum with respect to the first argument.
Let \(G\) be a simple graph with \(h(G) \geq 1\). Then \(\min (h(G), 1) = 1\), and for any graph \(G'\) with \(h(G') {\gt} h(G)\), we also have \(\min (h(G'), 1) = 1\).
We prove both parts. First, by the theorem that the Cheeger factor equals one when \(h(G) \geq 1\), we have \(\min (h(G), 1) = 1\).
Second, let \(G'\) be any graph with \(h(G') {\gt} h(G)\). Since \(h(G') {\gt} h(G) \geq 1\), we have \(h(G') \geq 1\). By the same theorem, \(\min (h(G'), 1) = 1\).
For any simple graph \(G\):
If \(h(G) \geq 1\), then \(\min (h(G), 1) = 1\).
If \(h(G) {\gt} 1\), then \(\min (h(G), 1) = 1\) (no improvement over case 1).
If \(h(G) {\lt} 1\), then \(\min (h(G), 1) = h(G) {\lt} 1\) (distance loss).
We prove each part:
This follows directly from the theorem that the Cheeger factor equals one when \(h(G) \geq 1\).
Since \(h(G) {\gt} 1\) implies \(h(G) \geq 1\), this follows from part 1.
Assuming \(h(G) {\lt} 1\), by the theorem that the Cheeger factor equals \(h(G)\) when \(h(G) {\lt} 1\), we have \(\min (h(G), 1) = h(G)\). Since \(h(G) {\lt} 1\), the Cheeger factor is also less than \(1\).
1.10 Logical Preservation
[Logical Preservation]
The gauging procedure preserves all quantum information except for the measured logical \(L\).
Bijection between logicals: There is a 1-1 correspondence between:
Logical operators of the deformed code
Logical operators of the original code that commute with \(L\)
Mapping:
Forward: A logical \(\tilde{P}\) of the original code commuting with \(L\) maps to its deformation \(\tilde{P} \cdot \prod _{e \in \gamma } Z_e\)
Backward: A logical \(L'\) of the deformed code maps to its restriction \(\bar{L}|_V\)
Kernel of the map: Operators equivalent to \(L\) map to stabilizers in the deformed code (since \(L\) is measured).
Algebra preservation: The commutation relations among logicals are preserved by this mapping.
No proof needed for remarks.
A commuting logical operator of a stabilizer code \(C\) with respect to a measured logical \(L\) is a structure consisting of:
A logical operator \(P\) of \(C\)
A proof that \(P\) commutes with \(L\), i.e., the Z-support of \(P\) has even overlap with the support of \(L\)
These are exactly the logical operators that can be deformed to become logical operators of the deformed code.
The underlying Pauli operator of a commuting logical \(P\).
The X-support of a commuting logical \(P\), defined as the X-support of its underlying Pauli operator.
The Z-support of a commuting logical \(P\), defined as the Z-support of its underlying Pauli operator.
The weight of a commuting logical \(P\), defined as the weight of its underlying logical operator.
For any commuting logical \(P\), we have \(|S_Z(P) \cap \text{supp}(L)| \equiv 0 \pmod{2}\).
This follows directly from the definition of commuting logical, which requires the commutation condition as part of its structure.
Two commuting logicals \(P\) and \(Q\) are equal if and only if their underlying Pauli operators are equal: \(P = Q \Leftrightarrow P.\text{toPauli} = Q.\text{toPauli}\).
We prove both directions. For the forward direction, if \(P = Q\) then rewriting yields \(P.\text{toPauli} = Q.\text{toPauli}\). For the backward direction, suppose \(P.\text{toPauli} = Q.\text{toPauli}\). We case split on the structure of \(P\) and \(Q\). Since the toPauli function extracts the operator field, and the operator determines the logical uniquely (by cases on the logical structure), we conclude that \(P = Q\).
Two logical operators \(P\) and \(Q\) are equivalent if their product \(P \cdot Q\) is a stabilizer element of the code \(C\).
Logical operator equivalence is reflexive: for any logical operator \(P\), we have \(P \equiv P\).
We unfold the definition of logical operator equivalence. Since \(P \cdot P\) has trivial Pauli action (the symmetric difference of any set with itself is empty), we witness this by the empty set of checks. Using the fact that the product of an empty set of checks is the identity, we verify that the symmetric differences of both X-support and Z-support are empty by simplification.
Logical operator equivalence is symmetric: if \(P \equiv Q\) then \(Q \equiv P\).
We unfold the definitions. From the hypothesis \(P \equiv Q\), we obtain a set of checks \(T\) such that \(\prod T\) has the same Pauli action as \(P \cdot Q\). We use the same set \(T\) for the converse. Since \(Q \cdot P\) has the same Pauli action as \(P \cdot Q\) (by commutativity of symmetric difference on supports), the result follows.
A commuting logical \(P\) is equivalent to \(L\) if the product \(P \cdot L\) (where \(L\) is viewed as an X-type Pauli) is a stabilizer element.
A deformed logical operator for a deformation configuration \(D\) is a structure consisting of:
An underlying deformed operator
A proof that the original operator is a logical: it commutes with all checks and is not a stabilizer element
The original Pauli operator (the \(P\) part of \(P \cdot \prod Z_e\)) of a deformed logical.
The edge path \(\gamma \) (which determines \(\prod _{e \in \gamma } Z_e\)) of a deformed logical.
The X-support on original qubits of a deformed logical.
The Z-support on original qubits of a deformed logical.
The edge Z-support of a deformed logical, which equals the edge path \(\gamma \). This encodes the product \(\prod _{e \in \gamma } Z_e\).
Two deformed logicals \(P\) and \(Q\) are equal if and only if their underlying deformed operators are equal.
We prove both directions. The forward direction follows by rewriting. For the backward direction, we case split on the structures of \(P\) and \(Q\), and use the fact that the deformed operator determines the entire structure.
Constructs a deformed logical from:
A commuting logical \(P\)
An edge path \(\gamma \) with valid edges
A proof that \(\gamma \) satisfies the boundary condition
Proofs that \(P\) commutes with all checks and is not a stabilizer
The symplectic form on original qubits between two Pauli operators \(P_1\) and \(P_2\) is defined as:
The X-support of a deformed operator on edge qubits is always empty. This is because the deformation \(P \cdot \prod _{e \in \gamma } Z_e\) adds only Z-type operators on edges.
The Z-support of a deformed operator on edge qubits is exactly the edge path \(\gamma \).
The edge contribution to the symplectic form between two deformed operators \(P_1\) and \(P_2\) is:
For any two deformed operators \(P_1\) and \(P_2\), the edge symplectic contribution is zero: \(\omega _{\text{edge}}(P_1, P_2) = 0\).
We unfold the definitions. Since \(X_{\text{edge}}(\tilde{P}_1) = \emptyset \) and \(X_{\text{edge}}(\tilde{P}_2) = \emptyset \) (deformations add only Z operators on edges), we have:
\(|\emptyset \cap \gamma _2| = 0\)
\(|\gamma _1 \cap \emptyset | = 0\)
Therefore the total edge contribution is \(0 + 0 = 0\).
The full symplectic form on the extended system (original qubits \(\otimes \) edge qubits) is:
For any two deformed operators \(P_1\) and \(P_2\):
The edge contribution vanishes because deformations add only Z-type operators on edges.
We unfold the definition of the full symplectic form and apply the lemma that the edge symplectic form is zero. By ring arithmetic, the result follows.
The forward map takes a commuting logical \(P\) and an edge path \(\gamma \) (satisfying the boundary condition) to the deformed operator \((P, \gamma )\) representing \(P \cdot \prod _{e \in \gamma } Z_e\) on the extended system.
The original qubit part of the forward map is \(P\): for a commuting logical \(P\) and edge path \(\gamma \), the original component of \(\text{forwardMap}(P, \gamma )\) equals \(P.\text{toPauli}\).
This holds by reflexivity, as the forward map directly stores \(P.\text{toPauli}\) in the original field.
The edge Z-support of the forward map is \(\gamma \): \(Z_{\text{edge}}(\text{forwardMap}(P, \gamma )) = \gamma \).
This holds by reflexivity.
The edge X-support of the forward map is empty: \(X_{\text{edge}}(\text{forwardMap}(P, \gamma )) = \emptyset \).
This holds by reflexivity, as deformations add only Z operators on edges.
The backward map extracts the original qubit part from a deformed logical: \(\tilde{P} = P \cdot \prod Z_e \mapsto P\). This is the restriction to original qubits.
The backward map gives an operator that commutes with all original checks.
This follows directly from the is_logical condition in the deformed logical structure, which ensures the original operator commutes with all checks.
The backward map gives an operator that is not a stabilizer element.
This follows directly from the is_logical condition in the deformed logical structure, which ensures the original operator is not a stabilizer.
The backward map yields a logical operator of the original code, using the proofs that it commutes with all checks and is not a stabilizer.
The backward map yields a commuting logical, using the commutation condition from the deformed operator structure.
The backward map is injective on the original Pauli: if two deformed logicals have the same backward image, then their original Pauli parts are equal.
We unfold the definitions. The backward map extracts the original field, so if \(\text{backwardMap}(P_1) = \text{backwardMap}(P_2)\), then \(P_1.\text{original} = P_2.\text{original}\) by the definition.
The forward-then-backward round-trip preserves the original Pauli: \(P \mapsto P \cdot \prod Z_e \mapsto P\).
By simplification. The forward map stores \(P.\text{toPauli}\) in the original field, and the backward map extracts the original field. Therefore the composition returns \(P.\text{toPauli}\).
The backward-then-forward round-trip preserves the original Pauli (though the edge path may differ).
By simplification of the definitions.
If two deformed operators have the same original Pauli, then their edge paths differ by a cycle: \(\gamma _1 \oplus \gamma _2 \in \ker (\partial _1)\).
Let \(w\) be an arbitrary vertex. Both operators satisfy the same boundary condition (since their original parts are equal). By rewriting using the equality of original parts, both edge paths satisfy the boundary condition for the same target. By the theorem that the difference of two paths with the same target boundary is a cycle, the symmetric difference \(\gamma _1 \oplus \gamma _2\) has zero boundary at \(w\).
For any choice of edge paths satisfying the boundary condition, the forward map preserves the original Pauli.
Both forward map constructions store the same \(P.\text{toPauli}\) in the original field. By simplification, the result follows.
The logical \(L\) viewed as a Pauli operator: an X-type operator with support on \(L.\text{support}\).
The logical \(L\) has empty Z-support: \(S_Z(L) = \emptyset \).
By simplification of the definitions. An X-type Pauli has Z-support equal to the empty set.
The target boundary of \(L\) is zero at every vertex: \(\partial _{\text{target}}(L, w) = 0\) for all \(w\).
We unfold the definitions. Since \(L\) is X-type, its Z-support is empty. Therefore for any vertex \(w\), there is no element in the Z-support at \(w\), making the target boundary zero.
The logical \(L\) can be deformed with the empty edge path: since \(S_Z(L) = \emptyset \), the boundary condition is satisfied.
Let \(w\) be an arbitrary vertex. The edge path boundary of the empty set is zero (filtering an empty set gives an empty set with cardinality zero). By the lemma that \(L\)’s target boundary is zero, the symmetry gives the boundary condition.
The logical \(L\) commutes with itself (trivially, as it is X-type with empty Z-support).
We unfold the definitions. The Z-support of an X-type Pauli is empty, so the intersection with any set is empty, which has cardinality \(0 \equiv 0 \pmod{2}\).
If \(P\) is equivalent to \(L\) (i.e., \(P \cdot L\) is a stabilizer), then there exists a set of checks \(T\) such that \(\prod T\) has the same Pauli action as \(P \cdot L\).
By definition of isEquivalentToL, \(P \cdot L_{\text{asPauli}}\) is a stabilizer element. Unfolding the definitions gives the result directly.
Conversely, if there exists a set of checks \(T\) such that \(\prod T\) has the same Pauli action as \(P \cdot L\), then \(P\) is equivalent to \(L\).
We unfold the definition of isEquivalentToL. Since LToPauli equals XTypePauli, simplification in the hypothesis gives the result directly.
A commuting logical \(P\) is equivalent to \(L\) if and only if \(P \cdot L\) is a stabilizer element.
By unfolding the definitions. The statement isEquivalentToL is defined as exactly this condition, so the equivalence holds by reflexivity.
Two Pauli operators commute if and only if their symplectic form is even: \([P, Q] = 0 \Leftrightarrow \omega _{\text{original}}(P, Q) \equiv 0 \pmod{2}\).
By unfolding the definitions. Commutativity of Pauli operators is defined in terms of the parity of overlaps, which equals the symplectic form.
If two commuting logicals \(P\) and \(Q\) commute in the original code, their deformations commute in the deformed code: \([P, Q] = 0 \Rightarrow [\tilde{P}, \tilde{Q}] = 0\).
We rewrite using the theorem that the full symplectic form equals the original symplectic form. By simplification, the forward map preserves the original Pauli. By hypothesis, the original Paulis commute, giving the result.
Commutation is preserved in both directions: \([P, Q] = 0 \Leftrightarrow [\tilde{P}, \tilde{Q}] = 0\).
We prove both directions. The forward direction follows from commutation_preserved. For the backward direction, we rewrite using symplecticFull_eq_original and simplify using the forward map definition to recover the original commutation condition.
The main logical preservation correspondence theorem establishes five key properties:
Forward-backward preserves Pauli: \(P \mapsto P \cdot \prod Z_e \mapsto P\)
Backward-forward preserves Pauli: \((P, \gamma ) \mapsto P \mapsto (P, \gamma ')\) (same \(P\), possibly different \(\gamma \))
Full symplectic form preserved: \(\omega _{\text{full}} = \omega _{\text{original}}\) (edge contribution \(= 0\))
Commutation preserved: \([P, Q] = 0 \Rightarrow [\tilde{P}, \tilde{Q}] = 0\)
Kernel characterization: \(P \equiv L \Leftrightarrow P \cdot L \in \text{Stabilizers}\)
We construct the conjunction of all five parts:
Part 1 follows from forward_then_backward.
Part 2 follows from backward_then_forward.
Part 3 follows from symplecticFull_eq_original.
Part 4 follows from commutation_preserved.
Part 5: For any commuting logical \(P\), the equivalence follows from kernel_iff_product_stabilizer.
The weight of a commuting logical equals the weight of its underlying logical operator.
This holds by reflexivity.
The original X-support of a deformed logical equals the original X-support of its underlying deformed operator.
This holds by reflexivity.
The original Z-support of a deformed logical equals the original Z-support of its underlying deformed operator.
This holds by reflexivity.
The Z-support of \(L\) as a Pauli is empty: \((L.\text{toPauli}).S_Z = \emptyset \).
By simplification of the definitions.
The X-support of \(L\) as a Pauli equals \(L.\text{support}\): \((L.\text{toPauli}).S_X = L.\text{support}\).
By simplification of the definitions.
The backward map preserves the commutation condition with \(L\).
This follows from the commutes_with_L field of the deformed operator structure.
The backward map extracts the original operator: \((P.\text{backwardMapToCommutingLogical}).\text{logical}.\text{operator} = P.\text{original}\).
This holds by reflexivity.
If two deformed operators have different original parts, they are different: \(P.\text{original} \neq Q.\text{original} \Rightarrow P \neq Q\).
Assume for contradiction that \(P = Q\). Then by rewriting, \(P.\text{original} = Q.\text{original}\), contradicting the hypothesis.
The product \(L \cdot L\) has identity Pauli action (X-type operators square to identity on supports): \(L \cdot L \sim I\).
We unfold the definitions and prove both conditions for samePauliAction. For both X-support and Z-support, the symmetric difference of a set with itself is empty, matching the identity operator’s supports.
The edge symplectic form is symmetric: \(\omega _{\text{edge}}(P_1, P_2) = \omega _{\text{edge}}(P_2, P_1)\).
We unfold the definitions. Since the X-support on edges is empty for all deformed operators, both terms in each direction are \(|\emptyset \cap \cdot | = 0\), making both sides equal to \(0\).
[Circuit Implementation of Gauging Measurement]
The gauging measurement procedure can be implemented by a quantum circuit with no additional qubits beyond the edge qubits.
Circuit steps:
Initialize edge qubits: \(|0\rangle _E\)
Apply entangling circuit: \(\prod _v \prod _{e \ni v} \mathrm{CX}_{v \to e}\) where \(\mathrm{CX}_{v \to e}\) is controlled-X from vertex \(v\) to edge \(e\)
Measure \(X_v\) on all vertices \(v \in V\) and record outcomes
Apply the same entangling circuit again: \(\prod _v \prod _{e \ni v} \mathrm{CX}_{v \to e}\)
Measure \(Z_e\) on all edges and discard edge qubits
Apply byproduct corrections based on measurement outcomes
Verification: The composition of steps 2–3 is equivalent to measuring \(A_v = X_v \prod _{e \ni v} X_e\) because:
After step 2: CX entangles vertex and edge qubits
Measuring \(X_v\) in step 3 effectively measures \(A_v\) in the original basis
Step 4 disentangles for the \(Z_e\) measurements
No proof needed for remarks.
The circuit steps in order form a list of exactly six steps:
The circuit has exactly 6 steps: \(|\text{circuitStepOrder}| = 6\).
This holds by reflexivity (definitional equality).
A CX (controlled-X or CNOT) gate is specified by a control vertex and a target edge. Given a stabilizer code \(C\) with \(n\) qubits and \(k\) logical qubits, an X-type logical operator \(L\), and a gauging graph \(G\), a CX gate consists of:
A control vertex \(v \in G.\text{Vertex}\)
A target edge \(e \in \text{Sym}_2(G.\text{Vertex})\)
A proof that the edge is incident to the control vertex: \(v \in e\)
Two CX gates \(g_1\) and \(g_2\) are equal if and only if they have the same control vertex and target edge:
We prove both directions. For the forward direction, assume \(g_1 = g_2\). Then by rewriting, both equalities hold by reflexivity. For the reverse direction, assume \(g_1.\text{controlVertex} = g_2.\text{controlVertex}\) and \(g_1.\text{targetEdge} = g_2.\text{targetEdge}\). We perform case analysis on \(g_1\) and \(g_2\), destructuring them into their components. Using simplification on the hypotheses, we substitute the equalities and conclude by reflexivity.
A Pauli operator on the extended system (vertex qubits + edge qubits), represented by X and Z supports on both vertices and edges:
\(\text{originalX} : \text{Finset}(\text{Fin } n)\) — X-support on original code qubits
\(\text{originalZ} : \text{Finset}(\text{Fin } n)\) — Z-support on original code qubits
\(\text{vertexX} : G.\text{Vertex} \to \mathbb {Z}/2\mathbb {Z}\) — X-support on vertex qubits
\(\text{vertexZ} : G.\text{Vertex} \to \mathbb {Z}/2\mathbb {Z}\) — Z-support on vertex qubits
\(\text{edgeX} : \text{Sym}_2(G.\text{Vertex}) \to \mathbb {Z}/2\mathbb {Z}\) — X-support on edge qubits
\(\text{edgeZ} : \text{Sym}_2(G.\text{Vertex}) \to \mathbb {Z}/2\mathbb {Z}\) — Z-support on edge qubits
The identity operator on the extended system has empty supports:
\(\text{originalX} = \emptyset \), \(\text{originalZ} = \emptyset \)
\(\text{vertexX}(v) = 0\), \(\text{vertexZ}(v) = 0\) for all \(v\)
\(\text{edgeX}(e) = 0\), \(\text{edgeZ}(e) = 0\) for all \(e\)
The X operator on a single vertex \(v\) is defined by:
with all other supports zero.
The X operator on a single edge \(e\) is defined by:
with all other supports zero.
The Z operator on a single vertex \(v\) is defined by:
with all other supports zero.
The Z operator on a single edge \(e\) is defined by:
with all other supports zero.
The product of two extended Pauli operators \(P\) and \(Q\) is defined using XOR (symmetric difference) of supports in \(\mathbb {Z}/2\mathbb {Z}\) algebra:
Two extended Pauli operators \(P\) and \(Q\) are equal if and only if all their components are equal:
We perform case analysis on \(P\) and \(Q\). Using simplification on all the hypotheses, we substitute each component equality and conclude by reflexivity.
For extended Pauli operators \(P\) and \(Q\): \(P \cdot Q = Q \cdot P\).
We unfold the multiplication definition and apply extensionality. For the original supports, we use commutativity of symmetric difference. For the vertex and edge supports, we use function extensionality and ring arithmetic (commutativity of addition in \(\mathbb {Z}/2\mathbb {Z}\)).
For extended Pauli operators \(P\), \(Q\), and \(R\): \((P \cdot Q) \cdot R = P \cdot (Q \cdot R)\).
We unfold the multiplication definition and apply extensionality. For the original supports, we use associativity of symmetric difference. For the vertex and edge supports, we use function extensionality and ring arithmetic (associativity of addition in \(\mathbb {Z}/2\mathbb {Z}\)).
For any extended Pauli operator \(P\): \(\text{identity} \cdot P = P\).
We unfold the multiplication and identity definitions and apply extensionality. For the original supports, we simplify using properties of symmetric difference with the empty set: \(\emptyset \triangle S = S\). For the vertex and edge supports, we use function extensionality and simplify using \(0 + x = x\) in \(\mathbb {Z}/2\mathbb {Z}\).
For any extended Pauli operator \(P\): \(P \cdot \text{identity} = P\).
We rewrite using commutativity of multiplication and then apply the left identity theorem.
CX conjugation transforms \(X_v\) to \(X_v \otimes X_e\) (X on control spreads to target). In \(\mathbb {Z}/2\mathbb {Z}\) terms:
CX conjugation transforms \(Z_e\) to \(Z_v \otimes Z_e\) (Z on target spreads to control). In \(\mathbb {Z}/2\mathbb {Z}\) terms:
Full CX conjugation combines both X and Z transformations:
while preserving the original supports and other components.
Applying CX conjugation twice returns the original operator. For any CX gate and extended Pauli operator \(P\):
This follows from the fact that CX is both Hermitian and unitary: \(\text{CX}^\dagger = \text{CX}\).
We unfold the CX conjugation definition and apply extensionality. The original supports are unchanged (reflexivity). For the vertexX, we have reflexivity since CX doesn’t modify it. For vertexZ, we consider two cases: if \(v = \text{controlVertex}\), then simplifying and using that \(x + x = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), we compute:
Otherwise, simplification gives the result directly. Similarly for edgeX: if \(e = \text{targetEdge}\), then:
The edgeZ component is unchanged by CX conjugation.
The Gauss law operator \(A_v = X_v \prod _{e \ni v} X_e\) as an extended Pauli operator:
with all Z-supports zero.
The starting operator \(X_v\) on vertex only (before CX transformation):
with all other supports zero.
The Gauss law extended operator satisfies:
The vertex X part is preserved: \((\text{gaussLawExtended } G \, v).\text{vertexX}(v) = 1\)
The edge X part equals the incidence indicator: for all \(e\), \((\text{gaussLawExtended } G \, v).\text{edgeX}(e) = [v \in e]\)
The Z parts are zero: for all \(w\) and \(e\), \(\text{vertexZ}(w) = 0\) and \(\text{edgeZ}(e) = 0\)
We unfold the gaussLawExtended definition and all claims follow by simplification using the conditional expressions.
The set of CX gates for the entangling circuit. For each vertex \(v\) and each edge \(e\) incident to \(v\), we have \(\text{CX}_{v \to e}\):
The number of CX gates with a given edge as target equals 2 (one from each endpoint). For any edge \(e \in G.\text{graph.edgeSet}\):
We revert the edge set membership hypothesis and use Sym2.ind to decompose the edge \(e\) into a pair \((v, w)\). Let \(h_{\text{adj}}\) be the adjacency proof, from which we obtain \(v \neq w\). We show that the filter set \(\{ x \mid x \in s(v, w)\} \) equals \(\{ v, w\} \) by extensionality, using the characterization of Sym2 membership. Then by the card_pair lemma, \(|\{ v, w\} | = 2\) since \(v \neq w\).
State after step 1: edge qubits initialized to \(|0\rangle \). In terms of Pauli eigenvalues, all \(Z_e\) have eigenvalue \(+1\):
\(\text{edge\_ z\_ eigenvalue} : \text{Sym}_2(G.\text{Vertex}) \to \mathbb {Z}/2\mathbb {Z}\)
\(\text{all\_ plus}\): for all \(e\), \(\text{edge\_ z\_ eigenvalue}(e) = 0\) (representing \(+1\))
Measuring \(X_v\) in step 3 effectively measures \(A_v\). After applying the entangling circuit:
\((\text{gaussLawExtended } G \, v).\text{vertexX}(v) = (\text{vertexXOnly } G \, v).\text{vertexX}(v)\)
For all \(e\) with \(v \in e\): \((\text{gaussLawExtended } G \, v).\text{edgeX}(e) = 1\)
We unfold both definitions. The first equality follows by simplification since both evaluate to 1 when the vertex matches. For the second claim, let \(e\) be an edge with \(v \in e\). Then simplification using the incidence hypothesis gives the result.
The transformation from \(X_v\) to \(A_v\) via CX conjugation. For any vertex \(v\), edge \(e\) with \(v \in e\) and \(e\) in the edge set:
We simplify using the definitions of cxConjugate and vertexXOnly. Since \(e\) equals the target edge, the edge X support becomes \(0 + 1 = 1\).
The entangling circuit is self-inverse. Applying it twice returns to the original (unentangled) state. For any CX gate and extended Pauli operator \(P\):
This follows directly from the cx_self_inverse theorem applied to each CX gate.
After step 4, the vertex and edge supports return to their original (unentangled) form. For any CX gate and Pauli operator \(P\):
We first establish \(h := \text{cx\_ self\_ inverse } cx \, P\). Then each component equality follows by rewriting with \(h\).
After applying CX twice, the edge Z-support and vertex Z-support are restored:
We first establish \(h := \text{cx\_ self\_ inverse } cx \, P\). Then both equalities follow by taking the appropriate component projections of \(h\).
The circuit implementation is equivalent to the abstract gauging measurement. For any measurement configuration \(M\):
The product of outcomes \(\sigma \in \{ 0, 1\} \) (representing \(\pm 1\)): for all outcomes, \(\prod _v \varepsilon _v \in \{ 0, 1\} \)
The kernel of \(\delta _0\) characterizes the cocycle structure: for all \(c\), if \(\delta _0(c) = 0\) then \(c = 0_V\) or \(c = \mathbf{1}_V\)
Gauss law product equals logical operator support: for all \(v\), \(\text{productVertexSupport}(G, v) = 1\)
We prove each part separately. For part 1, let outcomes be given. The value of productOfGaussOutcomes is in \(\mathbb {Z}/2\mathbb {Z}\), so its underlying value is less than 2. By case analysis (omega), the value is either 0 or 1, and we use Fin.ext to convert to the type-level equality. For part 2, this follows directly from ker_delta0_connected applied to \(M\). For part 3, this follows directly from gaussLaw_product_eq_logical applied to \(M\).
The total qubit count for the circuit:
where \(n\) is the number of original code qubits and \(|E|\) is the number of edges.
The qubits partition into code qubits and edge qubits:
This holds by reflexivity (definitional equality).
No additional ancilla qubits beyond edge qubits are required. The circuit implementation requires exactly:
\(n\) original code qubits
\(|E|\) edge qubits
0 additional ancilla qubits
This holds by reflexivity (definitional equality).
The maximum vertex degree in the gauging graph:
Each vertex \(v\) contributes at most \(\deg (v)\) CX gates:
We unfold the definition of maxVertexDegree. The result follows from Finset.le_sup applied to the function mapping each vertex to its incident edge count, with the fact that \(v \in \text{Finset.univ}\).
Total CX gate count equals \(2|E|\). Each edge \(e = \{ v, w\} \) contributes exactly 2 CX gates: \(\text{CX}_{v \to e}\) and \(\text{CX}_{w \to e}\).
This is the handshaking lemma. We prove this by swapping the order of summation:
The intermediate steps use card_eq_sum_ones and sum_filter to convert between cardinalities and indicator sums.
The circuit step enumeration covers all steps. For any circuit step \(s\):
We perform case analysis on \(s\), covering all six constructors of CircuitStep. In each case, simplification using the circuitStepOrder definition shows membership.
Step indices are valid: \(|\text{circuitStepOrder}| = 6\).
This holds by reflexivity.
For any vertex \(v\): \((\text{identity}).\text{vertexX}(v) = 0\).
This holds by reflexivity (definitional equality).
For any vertex \(v\): \((\text{identity}).\text{vertexZ}(v) = 0\).
This holds by reflexivity (definitional equality).
For any edge \(e\): \((\text{identity}).\text{edgeX}(e) = 0\).
This holds by reflexivity (definitional equality).
For any edge \(e\): \((\text{identity}).\text{edgeZ}(e) = 0\).
This holds by reflexivity (definitional equality).
The Gauss law operator has X-support on vertex \(v\):
We unfold the gaussLawExtended definition and simplify using the conditional expression.
The Gauss law operator has X-support on incident edges. For any edge \(e\) with \(v \in e\):
We unfold the gaussLawExtended definition and simplify using the incidence hypothesis \(v \in e\).
The Gauss law operator has no Z-support:
For all \(w\): \((\text{gaussLawExtended } G \, v).\text{vertexZ}(w) = 0\)
For all \(e\): \((\text{gaussLawExtended } G \, v).\text{edgeZ}(e) = 0\)
We unfold the gaussLawExtended definition and simplify.
CX conjugation preserves the original qubit supports:
We unfold the cxConjugate definition and simplify.
[Parallelization of Gauging Measurement]
The gauging measurement can be applied to multiple logical operators in parallel, subject to compatibility conditions:
Compatibility condition: Logical operators \(L_1, \ldots , L_m\) can be measured in parallel if no pair acts on a common qubit via different non-trivial Pauli operators. Specifically, for all \(i \neq j\) and all qubits \(v\), at least one of the following holds:
\(v \notin \mathrm{supp}(L_i)\), or
\(v \notin \mathrm{supp}(L_j)\), or
\(L_i\) and \(L_j\) act on \(v\) by the same Pauli (\(X\), \(Y\), or \(Z\)).
LDPC preservation: To maintain an LDPC deformed code, at most a constant number of logical operators being measured should share support on any single qubit.
Time-space tradeoff: Instead of \(d\) rounds of syndrome measurement, one can perform:
\(d/m\) rounds of syndrome measurement,
Measure \(2m - 1\) equivalent logical operators in parallel,
Take majority vote to determine the classical outcome.
This trades space overhead (more parallel measurements) for time overhead (fewer rounds).
No proof needed for remarks.
The three non-trivial Pauli operators are enumerated as:
\(X\): the Pauli \(X\) operator,
\(Y\): the Pauli \(Y\) operator,
\(Z\): the Pauli \(Z\) operator.
Given two Pauli types \(p_1\) and \(p_2\), their combination is defined by the Pauli multiplication table (up to phase):
\(X \cdot X = X\), \(Y \cdot Y = Y\), \(Z \cdot Z = Z\) (same types combine to themselves),
\(X \cdot Z = Y\), \(Z \cdot X = Y\),
\(X \cdot Y = Z\), \(Y \cdot X = Z\),
\(Y \cdot Z = X\), \(Z \cdot Y = X\).
For any Pauli type \(p\), we have \(\mathrm{combine}(p, p) = \mathrm{some}(p)\).
We proceed by cases on the Pauli type \(p\). For each case (\(X\), \(Y\), or \(Z\)), this holds by reflexivity from the definition of combine.
For any Pauli types \(p_1\) and \(p_2\), we have \(\mathrm{combine}(p_1, p_2) = \mathrm{combine}(p_2, p_1)\).
We proceed by cases on \(p_1\) and \(p_2\). For each of the nine combinations, this holds by reflexivity from the symmetric definition of combine.
The Pauli action of a stabilizer check \(s\) at a specific qubit \(v\) is defined as:
If \(v \in \mathrm{supportX}(s)\) and \(v \in \mathrm{supportZ}(s)\), then the action is \(Y\),
If \(v \in \mathrm{supportX}(s)\) and \(v \notin \mathrm{supportZ}(s)\), then the action is \(X\),
If \(v \notin \mathrm{supportX}(s)\) and \(v \in \mathrm{supportZ}(s)\), then the action is \(Z\),
If \(v \notin \mathrm{supportX}(s)\) and \(v \notin \mathrm{supportZ}(s)\), then the action is \(\mathrm{none}\) (identity).
For a stabilizer check \(s\) and qubit \(v\), we have \(\mathrm{pauliActionAt}(s, v) = \mathrm{none}\) if and only if \(v \notin \mathrm{supportX}(s)\) and \(v \notin \mathrm{supportZ}(s)\).
We prove both directions. For the forward direction, assume \(\mathrm{pauliActionAt}(s, v) = \mathrm{none}\). We consider cases on whether \(v \in \mathrm{supportX}(s)\) and \(v \in \mathrm{supportZ}(s)\). By the definition of pauliActionAt, if either membership holds, the result would be \(\mathrm{some}(\cdot )\), not \(\mathrm{none}\). Thus both non-memberships hold. For the reverse direction, if \(v \notin \mathrm{supportX}(s)\) and \(v \notin \mathrm{supportZ}(s)\), then by simplification using the definition, the result is \(\mathrm{none}\).
If \(v \notin \mathrm{supportX}(s)\) and \(v \notin \mathrm{supportZ}(s)\), then \(\mathrm{pauliActionAt}(s, v) = \mathrm{none}\).
Rewriting using the characterization in Theorem 1069, the goal follows directly from the hypotheses.
For an X-type Pauli operator with support set \(S\) and qubit \(v \in S\), we have \(\mathrm{pauliActionAt}(\mathrm{XTypePauli}(n, S), v) = \mathrm{some}(X)\).
Unfolding the definitions of pauliActionAt and XTypePauli, and using that \(v \in S\) and the \(Z\)-support of an X-type operator is empty, simplification yields \(\mathrm{some}(X)\).
For a Z-type Pauli operator with support set \(S\) and qubit \(v \in S\), we have \(\mathrm{pauliActionAt}(\mathrm{ZTypePauli}(n, S), v) = \mathrm{some}(Z)\).
Unfolding the definitions of pauliActionAt and ZTypePauli, and using that the \(X\)-support of a Z-type operator is empty while \(v \in S\), simplification yields \(\mathrm{some}(Z)\).
Two stabilizer checks \(s_1\) and \(s_2\) are compatible at qubit \(v\) if at least one of the following holds:
\(\mathrm{pauliActionAt}(s_1, v) = \mathrm{none}\) (i.e., \(s_1\) acts trivially at \(v\)), or
\(\mathrm{pauliActionAt}(s_2, v) = \mathrm{none}\) (i.e., \(s_2\) acts trivially at \(v\)), or
\(\mathrm{pauliActionAt}(s_1, v) = \mathrm{pauliActionAt}(s_2, v)\) (both act by the same non-trivial Pauli).
For stabilizer checks \(s_1\), \(s_2\) and qubit \(v\), we have \(\mathrm{compatibleAt}(s_1, s_2, v) \Leftrightarrow \mathrm{compatibleAt}(s_2, s_1, v)\).
We prove both directions. In each direction, we case split on the three disjuncts in the definition of compatibleAt. The first two cases swap roles, and the third case uses symmetry of equality.
If \(v\) is not in the support of \(s_1\) (i.e., \(v \notin \mathrm{supportX}(s_1)\) and \(v \notin \mathrm{supportZ}(s_1)\)) or \(v\) is not in the support of \(s_2\), then \(s_1\) and \(s_2\) are compatible at \(v\).
Unfolding the definition of compatibleAt, we case split on whether the non-support condition holds for \(s_1\) or \(s_2\). In the first case, we establish that \(\mathrm{pauliActionAt}(s_1, v) = \mathrm{none}\) using Theorem 1070, giving the first disjunct. In the second case, similarly \(\mathrm{pauliActionAt}(s_2, v) = \mathrm{none}\), giving the second disjunct.
Two stabilizer checks \(s_1\) and \(s_2\) are fully compatible if they are compatible at every qubit \(v\), i.e., \(\forall v : \mathrm{Fin}(n), \mathrm{compatibleAt}(s_1, s_2, v)\).
For stabilizer checks \(s_1\) and \(s_2\), we have \(\mathrm{fullyCompatible}(s_1, s_2) \Leftrightarrow \mathrm{fullyCompatible}(s_2, s_1)\).
We prove both directions. In each direction, let \(v\) be an arbitrary qubit. We apply Theorem 1074 to rewrite compatibility at \(v\), then apply the hypothesis.
Every stabilizer check is fully compatible with itself.
Let \(v\) be an arbitrary qubit. We need to show \(\mathrm{compatibleAt}(s, s, v)\). The third disjunct holds by reflexivity: \(\mathrm{pauliActionAt}(s, v) = \mathrm{pauliActionAt}(s, v)\).
A set of logical operators \(\mathrm{ops}\) is parallel compatible if every pair of operators in the set is fully compatible, i.e., for all \(L_1 \in \mathrm{ops}\) and \(L_2 \in \mathrm{ops}\), we have \(\mathrm{fullyCompatible}(L_1.\mathrm{operator}, L_2.\mathrm{operator})\).
The empty set of logical operators is trivially parallel compatible.
By simplification, there are no pairs to check in the empty set.
For any logical operator \(L\), the singleton set \(\{ L\} \) is parallel compatible.
Let \(L_1, L_2 \in \{ L\} \). By the singleton membership, both equal \(L\). Rewriting, we need \(\mathrm{fullyCompatible}(L.\mathrm{operator}, L.\mathrm{operator})\), which follows from Theorem 1078.
If \(\mathrm{ops}_2\) is parallel compatible and \(\mathrm{ops}_1 \subseteq \mathrm{ops}_2\), then \(\mathrm{ops}_1\) is parallel compatible.
Let \(L_1 \in \mathrm{ops}_1\) and \(L_2 \in \mathrm{ops}_1\). By the subset hypothesis, \(L_1, L_2 \in \mathrm{ops}_2\). The result follows from the pairwise compatibility of \(\mathrm{ops}_2\).
For any two X-type logical operators \(L_1\) and \(L_2\) and any qubit \(v\), the operators \(\mathrm{XTypePauli}(n, L_1.\mathrm{support})\) and \(\mathrm{XTypePauli}(n, L_2.\mathrm{support})\) are compatible at \(v\).
Unfolding the definitions of compatibleAt, pauliActionAt, and XTypePauli, and noting that the \(Z\)-support of an X-type operator is empty, we case split on whether \(v \in L_1.\mathrm{support}\) and \(v \in L_2.\mathrm{support}\):
If both memberships hold, then both have \(X\) action, so the third disjunct holds.
If \(v \in L_1.\mathrm{support}\) but \(v \notin L_2.\mathrm{support}\), the second disjunct holds.
If \(v \notin L_1.\mathrm{support}\), the first disjunct holds.
All X-type logical operators are mutually fully compatible.
For any qubit \(v\), apply Theorem 1083.
A set of logical operators \(\mathrm{ops}\) satisfies LDPC preservation with constant \(c\) if for all qubits \(v\), at most \(c\) operators share support at \(v\):
The empty set of logical operators satisfies LDPC preservation with any constant \(c\).
By simplification, the shared support count for the empty set is zero at every qubit.
For any logical operator \(L\), the singleton set \(\{ L\} \) satisfies LDPC preservation with \(c = 1\).
For any qubit \(v\), the filter over \(\{ L\} \) has at most one element, so the count is at most 1.
If \(\mathrm{ops}_2\) satisfies LDPC preservation with constant \(c\) and \(\mathrm{ops}_1 \subseteq \mathrm{ops}_2\), then \(\mathrm{ops}_1\) satisfies LDPC preservation with the same constant \(c\).
For any qubit \(v\), the shared support count for \(\mathrm{ops}_1\) is at most that for \(\mathrm{ops}_2\) by monotonicity of filtering over subsets. The bound then follows from the hypothesis on \(\mathrm{ops}_2\).
The time-space tradeoff parameters consist of:
\(d\): the code distance,
\(m\): the number of parallel logical measurements, with \(m {\gt} 0\).
The number of syndrome measurement rounds in the tradeoff is \(\lfloor d / m \rfloor \).
The number of equivalent logical operators measured in parallel is \(2m - 1\).
With \(m = 1\), the number of syndrome rounds equals the distance \(d\).
By simplification, \(d / 1 = d\).
With \(m = 1\), the number of equivalent logical operators is \(1\).
This holds by reflexivity: \(2 \cdot 1 - 1 = 1\).
With \(m = d\) (and \(d {\gt} 0\)), the number of syndrome rounds equals \(1\).
By simplification, \(d / d = 1\) when \(d {\gt} 0\).
The number of equivalent logical operators equals \(2m - 1\).
This holds by reflexivity from the definition.
The product of syndrome rounds and parallel count is bounded by the distance: \(\lfloor d/m \rfloor \cdot m \leq d\).
This follows from the standard property of integer division: \(\lfloor d/m \rfloor \cdot m \leq d\).
The sum of syndrome rounds and equivalent logicals is at least the parallel count: \(\lfloor d/m \rfloor + (2m - 1) \geq m\).
This follows by integer arithmetic, using that \(2m - 1 \geq m\) when \(m \geq 1\).
The outcomes from \(m\) parallel measurements of equivalent logical operators is a function from \(\mathrm{Fin}(2m - 1)\) to \(\mathbb {Z}/2\mathbb {Z}\), where \(0\) represents \(+1\) and \(1\) represents \(-1\).
The count of \(+1\) outcomes (represented as \(0\) in \(\mathbb {Z}/2\mathbb {Z}\)) among parallel measurements.
The count of \(-1\) outcomes (represented as \(1\) in \(\mathbb {Z}/2\mathbb {Z}\)) among parallel measurements.
Every element \(x \in \mathbb {Z}/2\mathbb {Z}\) satisfies \(x = 0\) or \(x = 1\).
We proceed by case analysis on the finite type \(\mathbb {Z}/2\mathbb {Z}\). For each element, simplification shows the result.
The total number of measurements equals \(2m - 1\): \(\mathrm{countPlusOnes} + \mathrm{countMinusOnesParallel} = 2m - 1\).
Unfolding the definitions, we establish that the filtered sets are disjoint (an outcome cannot be both 0 and 1) and their union is the full set (by Theorem 1102). The result follows from the cardinality of disjoint union being the sum of cardinalities.
The majority vote result is \(0\) (representing \(+1\)) if more than half of the outcomes are \(+1\), and \(1\) (representing \(-1\)) otherwise.
If all outcomes agree and are \(+1\) (i.e., all outcomes equal 0), then the majority vote equals \(0\).
Unfolding the definition of majorityVote, we establish that when all outcomes are 0, the filter for 0 values equals the full set with cardinality \(2m - 1\), and the filter for 1 values is empty with cardinality 0. Since \(2m - 1 {\gt} 0\) for \(m {\gt} 0\), the comparison yields the first branch, giving result 0.
A parallel gauging configuration for a stabilizer code \(C\) consists of:
A positive count \(m {\gt} 0\) of logical operators,
An assignment of X-type logical operators with associated gauging graphs,
A proof that all pairs are fully compatible,
An LDPC bound \(c\) and proof that at most \(c\) operators share support at any qubit.
The \(i\)-th gauging graph in a parallel gauging configuration.
All X-type operators in a parallel gauging configuration are mutually compatible.
This follows directly from Theorem 1084.
For any time-space tradeoff parameters \(T\):
The syndrome rounds are bounded: \(\lfloor d/m \rfloor \leq d\).
The equivalent logicals are at least 1: \(2m - 1 \geq 1\).
The product gives a distance bound: \(\lfloor d/m \rfloor \cdot m \leq d\).
The total work is at least \(m\): \(\lfloor d/m \rfloor + (2m - 1) \geq m\).
We prove each part:
Part 1: Unfolding the definition of syndrome rounds, \(\lfloor d/m \rfloor \leq d\) follows from the standard property of integer division.
Part 2: Unfolding the definition of equivalent logicals, \(2m - 1 \geq 1\) follows by integer arithmetic from \(m {\gt} 0\).
Part 3: This follows directly from Theorem 1097.
Part 4: This follows directly from Theorem 1098.
With maximum parallelization (\(m = d\) for \(d {\gt} 0\)), we get 1 syndrome round and \(2d - 1\) equivalent logical measurements.
The first part follows from Theorem 1095. The second part follows by reflexivity from the definition.
With minimum parallelization (\(m = 1\) for \(d {\gt} 0\)), we get \(d\) syndrome rounds and 1 equivalent logical measurement.
The first part follows from Theorem 1093. The second part follows by reflexivity from the definition.
If the supports of two stabilizer checks are disjoint (i.e., \((s_1.\mathrm{supportX} \cup s_1.\mathrm{supportZ}) \cap (s_2.\mathrm{supportX} \cup s_2.\mathrm{supportZ}) = \emptyset \)), then they are fully compatible.
Let \(v\) be an arbitrary qubit. We unfold the definitions and case split on whether \(v \in s_1.\mathrm{supportX}\):
If \(v \in s_1.\mathrm{supportX}\), then \(v\) is in the union for \(s_1\). By disjointness, \(v\) is not in the union for \(s_2\), so \(v \notin s_2.\mathrm{supportX}\) and \(v \notin s_2.\mathrm{supportZ}\). By simplification, \(\mathrm{pauliActionAt}(s_2, v) = \mathrm{none}\), giving the second disjunct.
If \(v \notin s_1.\mathrm{supportX}\) but \(v \in s_1.\mathrm{supportZ}\), the same argument applies.
If \(v \notin s_1.\mathrm{supportX}\) and \(v \notin s_1.\mathrm{supportZ}\), then by simplification \(\mathrm{pauliActionAt}(s_1, v) = \mathrm{none}\), giving the first disjunct.
For X-type logical operators, the count of operators with \(v\) in their support equals the count with \(v\) in the union of \(X\)- and \(Z\)-supports of the corresponding X-type Pauli.
By congruence, it suffices to show the filter predicates are equivalent. Using that the \(X\)-support of \(\mathrm{XTypePauli}(n, L.\mathrm{support})\) equals \(L.\mathrm{support}\) and the \(Z\)-support is empty, the union equals \(L.\mathrm{support}\).
For any time-space tradeoff parameters \(T\), the parallel count is positive.
This follows directly from the field parallel_pos in the structure.
Unfolding the definition, the result follows from monotonicity of filtering over subsets and monotonicity of cardinality.
The number of equivalent logical operators \(2m - 1\) is odd (or zero if \(m = 0\)).
Unfolding the definition of equivalent logicals, we case split on whether \(m = 0\). If \(m = 0\), the result is 0, giving the second disjunct. Otherwise, using that \(m {\gt} 0\), we compute \((2m - 1) \mod 2 = 1\) by integer arithmetic.
[Hypergraph Generalization]
The gauging measurement procedure generalizes from graphs to hypergraphs. The key structures and results are:
Hypergraph gauging: Replace the graph \(G\) with a hypergraph \(H = (V, E)\) where \(E\) is a collection of hyperedges (subsets of \(V\) of arbitrary size).
Generalized Gauss’s law: For each vertex \(v\), define:
What can be measured: The hypergraph gauging measures the group of operators:
where \(B_e = \prod _{v \in e} Z_v\) are Z-type hyperedge checks.
This is equivalent to \(\ker (H^T)\) where \(H\) is the incidence matrix of the hypergraph over \(\mathbb {F}_2\).
Application: Measure multiple commuting logical operators simultaneously by choosing a hypergraph whose kernel is exactly the group generated by those logicals.
No proof needed for remarks.
A hypergraph \(H = (V, E)\) consists of:
A finite vertex set \(V\) (the type Vertex)
A finite hyperedge index set \(E\) (the type EdgeIdx)
A function \(\texttt{hyperedge} : E \to \mathcal{P}(V)\) assigning to each hyperedge index a subset of vertices
The constraint that each hyperedge is non-empty: for all \(e \in E\), \(\texttt{hyperedge}(e) \neq \emptyset \)
This generalizes simple graphs where each edge has exactly 2 vertices.
The number of vertices of a hypergraph \(H\) is \(|V| = \# (\texttt{Vertex})\).
The number of hyperedges of a hypergraph \(H\) is \(|E| = \# (\texttt{EdgeIdx})\).
For a hypergraph \(H\), vertex \(v\), and hyperedge index \(e\), we define \(\texttt{vertexInEdge}(v, e) = \texttt{true}\) if and only if \(v \in \texttt{hyperedge}(e)\).
The degree of a vertex \(v\) in a hypergraph \(H\) is the number of hyperedges containing \(v\):
The size of a hyperedge \(e\) in a hypergraph \(H\) is the number of vertices in it:
The incidence matrix \(H\) of a hypergraph over \(\mathbb {Z}/2\mathbb {Z}\) is a \(|V| \times |E|\) matrix defined by:
The transpose incidence matrix \(H^T\) is the \(|E| \times |V|\) matrix given by \((H^T)[e, v] = H[v, e]\).
The row sum of the incidence matrix equals the vertex degree modulo 2:
By definition of the incidence matrix, \(H[v, e] = 1\) if \(v \in \texttt{hyperedge}(e)\) and \(0\) otherwise. The sum counts exactly the number of hyperedges containing \(v\), which is \(\deg (v)\). Simplifying the conditional sum and using that \(\sum _e \mathbf{1}_{v \in e} = \deg (v)\), we obtain the result modulo 2.
The column sum of the incidence matrix equals the hyperedge size modulo 2:
By definition of the incidence matrix, \(H[v, e] = 1\) if \(v \in \texttt{hyperedge}(e)\) and \(0\) otherwise. The sum counts exactly the number of vertices in the hyperedge, which is \(|e|\). By simplification and filtering, we obtain the result modulo 2.
A Gauss law operator for hypergraph vertex \(v\) is the operator \(A_v = X_v \prod _{e : v \in e} X_e\). It is represented by:
The center vertex \(v\)
Vertex support: \(\texttt{vertexSupport}(w) = \begin{cases} 1 & \text{if } w = v \\ 0 & \text{otherwise} \end{cases}\)
Edge support: \(\texttt{edgeSupport}(e) = \begin{cases} 1 & \text{if } v \in \texttt{hyperedge}(e) \\ 0 & \text{otherwise} \end{cases}\)
The canonical Gauss law operator \(A_v\) for vertex \(v\) is constructed with:
\(\texttt{vertexSupport}(w) = \mathbf{1}_{w = v}\)
\(\texttt{edgeSupport}(e) = \mathbf{1}_{v \in \texttt{hyperedge}(e)}\)
The collection of all hypergraph Gauss law operators is the function \(V \to \texttt{HypergraphGaussLaw}(H)\) mapping each vertex \(v\) to \(A_v\).
The Z-support of a hypergraph Gauss law operator at vertex \(v\) is empty: \(\texttt{hypergraph\_ ZSupport}(H, v) = \emptyset \). These are purely X-type operators.
The Z-support on edges of a hypergraph Gauss law operator is also empty: \(\texttt{hypergraph\_ ZSupport\_ edges}(H, v) = \emptyset \).
The symplectic form for hypergraph Gauss law operators at vertices \(v\) and \(w\) is:
Since these are X-type operators, both Z-supports are empty.
For any vertices \(v, w\) in a hypergraph \(H\):
By definition, \(\omega (v, w) = |\emptyset | + |\emptyset | = 0 + 0 = 0\).
All hypergraph Gauss law operators commute. For any vertices \(v, w\) in a hypergraph \(H\):
This follows from them being purely X-type (no Z component).
By Theorem 1133, \(\omega (v, w) = 0\). Therefore \(0 \mod 2 = 0\).
A Z-type hyperedge check \(B_e = \prod _{v \in e} Z_v\) is represented by:
The hyperedge index \(e\)
Z-support: \(\texttt{zSupport}(v) = \begin{cases} 1 & \text{if } v \in \texttt{hyperedge}(e) \\ 0 & \text{otherwise} \end{cases}\)
X-support: \(\texttt{xSupport}(v) = 0\) for all \(v\)
The canonical Z-type hyperedge check \(B_e\) is constructed with:
\(\texttt{zSupport}(v) = \mathbf{1}_{v \in \texttt{hyperedge}(e)}\)
\(\texttt{xSupport}(v) = 0\)
The collection of all hyperedge checks is the function \(E \to \texttt{HyperedgeCheck}(H)\) mapping each hyperedge index \(e\) to \(B_e\).
An X-type vertex operator \(P = \prod _{v \in S} X_v\) is represented by its support function \(P : V \to \mathbb {Z}/2\mathbb {Z}\), where \(P(v) = 1\) if \(v \in S\) and \(P(v) = 0\) otherwise.
The symplectic form between an X-type operator \(P\) and a Z-type check \(B_e\) is:
An X-type operator \(P\) commutes with the Z-type check \(B_e\) if \(\omega (P, B_e) \mod 2 = 0\).
An X-type operator \(P\) commutes with all checks if \(P\) commutes with \(B_e\) for all hyperedges \(e \in E\).
The support vector of an X-operator \(P\) over \(\mathbb {Z}/2\mathbb {Z}\) is simply the function \(P : V \to \mathbb {Z}/2\mathbb {Z}\).
The matrix-vector product \(H^T \cdot P\) gives overlap counts modulo 2:
An X-type operator \(P\) is in the kernel of \(H^T\) if \(H^T \cdot P = 0\), i.e., \((H^T \cdot P)_e = 0\) for all hyperedges \(e\).
For any X-type operator \(P\) and hyperedge \(e\):
By definition, \((H^T \cdot P)_e = \sum _v H[v, e] \cdot P(v)\). For each vertex \(v\), the term \((1 \text{ if } v \in e \text{ else } 0) \cdot P(v)\) equals \(1\) if and only if both \(v \in e\) and \(P(v) = 1\). We verify this by case analysis: if \(v \in e\), then \(H[v, e] = 1\) and the product is \(P(v)\); if \(v \notin e\), then \(H[v, e] = 0\) and the product is \(0\). For the case \(P(v) = 1\), the contribution is \(1\) when \(v \in e\). For \(P(v) = 0\), we show \(P(v) = 0\) by analyzing that \((P(v)).\text{val} \in \{ 0, 1\} \) and using that \(P(v) \neq 1\) implies \(P(v) = 0\). Rewriting the sum using indicator functions and the filter characterization, we obtain the cardinality of the filter set modulo 2.
An X-type operator \(P\) commutes with all Z-type hyperedge checks \(B_e\) if and only if \(P \in \ker (H^T)\):
This is the algebraic characterization of measurable operators.
We prove both directions:
\((\Rightarrow )\) Assume \(P\) commutes with all checks. Let \(e\) be arbitrary. By hypothesis, \(\omega (P, B_e) \mod 2 = 0\). Rewriting using Lemma 1145, \((H^T \cdot P)_e = |\{ v : P(v) = 1 \land v \in e\} | \pmod{2}\). Since the cardinality is even (from the commutation condition), its cast to \(\mathbb {Z}/2\mathbb {Z}\) is \(0\).
\((\Leftarrow )\) Assume \(P \in \ker (H^T)\). Let \(e\) be arbitrary. Then \((H^T \cdot P)_e = 0\) in \(\mathbb {Z}/2\mathbb {Z}\). By Lemma 1145, the filter set cardinality cast to \(\mathbb {Z}/2\mathbb {Z}\) is \(0\). This means the cardinality modulo 2 is \(0\), so \(\omega (P, B_e) \mod 2 = 0\), establishing that \(P\) commutes with \(B_e\).
The measurable group of X-operators is:
This is isomorphic to \(\ker (H^T)\) as a \(\mathbb {Z}_2\)-vector space.
The measurable group equals the kernel of \(H^T\):
By extensionality, for any \(P\), membership in the measurable group is equivalent to membership in the kernel by Theorem 1146.
The zero operator (identity) is always in the measurable group.
Let \(e\) be any hyperedge. The filter set \(\{ v : 0 = 1 \land v \in e\} \) is empty since \(0 \neq 1\) in \(\mathbb {Z}/2\mathbb {Z}\). Therefore \(|\emptyset | = 0\) and \(0 \mod 2 = 0\), so the zero operator commutes with all checks.
The sum of two measurable operators is measurable. If \(P, Q \in \ker (H^T)\), then \((P + Q) \in \ker (H^T)\).
Assume \(P, Q \in \) measurable group. By Theorem 1146, both are in \(\ker (H^T)\). Let \(e\) be arbitrary. We have \((H^T \cdot P)_e = 0\) and \((H^T \cdot Q)_e = 0\). By distributivity of multiplication over addition:
Summing over all \(v\) and using linearity of finite sums:
Therefore \((P + Q) \in \ker (H^T)\), and by Theorem 1146, \((P + Q)\) is measurable.
The product vertex support is the sum of all Gauss law vertex supports:
Each vertex appears exactly once in the sum:
By definition, \((A_w).\texttt{vertexSupport}(v) = 1\) if \(v = w\) and \(0\) otherwise. The filter set \(\{ w : v = w\} \) equals \(\{ v\} \), which has cardinality \(1\). Using the sum over indicator functions, we get \(\sum _w \mathbf{1}_{v=w} = 1\). Therefore \(\texttt{productVertexSupport}(v) = 1\).
The product of all Gauss law operators gives all-ones support (the logical \(L\)):
By functional extensionality and Theorem 1152, for all \(v\), \(\texttt{productVertexSupport}(v) = 1\).
The product edge support is the sum of all Gauss law edge supports:
Edge \(e\) appears once for each vertex in it, so the sum equals \(|e| \mod 2\):
By definition, \((A_v).\texttt{edgeSupport}(e) = 1\) if \(v \in \texttt{hyperedge}(e)\) and \(0\) otherwise. Using the boolean sum characterization, \(\sum _v \mathbf{1}_{v \in e} = |\texttt{hyperedge}(e)| = |e|\). Taking this modulo 2 gives the result.
For hyperedges of even size, edge support cancels in the product:
By Theorem 1155, \(\texttt{productEdgeSupport}(e) = |e| \pmod{2}\). If \(|e|\) is even, then \(|e| \equiv 0 \pmod{2}\), so the cast to \(\mathbb {Z}/2\mathbb {Z}\) is \(0\).
Any X-operator in \(\ker (H^T)\) can be measured by the hypergraph gauging:
This follows directly from Theorem 1146 (the \(\Leftarrow \) direction).
Multiple operators can be measured simultaneously if they are all in \(\ker (H^T)\). For operators \(P_1, P_2, \ldots , P_n \in \ker (H^T)\):
Each \(P_i\) commutes with all \(B_e\) (so doesn’t disturb the checks)
The gauging measurement reveals the eigenvalues of all \(P_i\) simultaneously
Let \(i\) be arbitrary. By hypothesis, \(P_i \in \ker (H^T)\). By Theorem 1157, \(P_i\) commutes with all checks. Since \(i\) was arbitrary, all \(P_i\) commute with all checks.
The set of measurable operators is closed under sum (XOR). If \(P, Q \in \ker (H^T)\), then \((P + Q) \in \ker (H^T)\). This means \(\ker (H^T)\) forms a \(\mathbb {Z}_2\)-vector space of measurable operators.
Assume \(P, Q \in \ker (H^T)\). Let \(e\) be arbitrary. We have \((H^T \cdot P)_e = 0\) and \((H^T \cdot Q)_e = 0\). By distributivity:
Summing and using linearity:
The measurable group equals \(\ker (H^T)\) as sets:
By extensionality and Theorem 1146.
To measure a specific set of logical operators \(\{ L_1, \ldots , L_n\} \) simultaneously, choose a hypergraph \(H\) such that \(L_1, \ldots , L_n \in \ker (H^T)\). This is achieved when for each hyperedge \(e\), \(|\text{supp}(L_i) \cap e|\) is even:
\((\Rightarrow )\) Assume \(L \in \) measurable group. By Theorem 1146, \(L \in \ker (H^T)\). Let \(e\) be arbitrary. Then \((H^T \cdot L)_e = 0\) in \(\mathbb {Z}/2\mathbb {Z}\). By Lemma 1145, this means the filter set cardinality cast to \(\mathbb {Z}/2\mathbb {Z}\) is \(0\). Extracting the value shows the cardinality modulo 2 is \(0\), i.e., the cardinality is even.
\((\Leftarrow )\) Assume for all \(e\), the filter set has even cardinality. Then for each \(e\), the cast to \(\mathbb {Z}/2\mathbb {Z}\) is \(0\). By Lemma 1145, \((H^T \cdot L)_e = 0\). Thus \(L \in \ker (H^T)\), and by Theorem 1146, \(L\) is in the measurable group.
A hypergraph is a simple graph if all hyperedges have exactly 2 elements:
For simple graphs, edge supports always cancel (even size):
By Theorem 1156, it suffices to show \(|e|\) is even. Since \(H\) is a simple graph, \(|e| = 2\). Since \(2 = 2 \cdot 1\), the size is even.
The constraint for simple graphs: product of all \(A_v\) equals the logical \(L\):
The all-ones support is always in the measurable group for 2-uniform hypergraphs (simple graphs):
Let \(e\) be any hyperedge. By definition of the matrix-vector product with the all-ones operator:
Using the boolean sum characterization, this equals \(|\texttt{hyperedge}(e)|\). The filter set \(\{ v : v \in e\} \) equals \(\texttt{hyperedge}(e)\), so the cardinality is \(|e|\). Since \(H\) is a simple graph, \(|e| = 2\). In \(\mathbb {Z}/2\mathbb {Z}\), we have \(2 = 0\) (verified by computation). Therefore \((H^T \cdot \mathbf{1})_e = 0\) for all \(e\), so \(\mathbf{1} \in \ker (H^T)\), and by Theorem 1146, \(\mathbf{1}\) is in the measurable group.
A time step is a natural number \(t \in \mathbb {N}\) representing a discrete time index in the circuit execution.
For an \(n\)-qubit system, a qubit index is an element \(q \in \{ 0, 1, \ldots , n-1\} \).
For a system with \(m\) check operators, a measurement index is an element \(i \in \{ 0, 1, \ldots , m-1\} \) identifying which measurement (check operator) is being performed.
The classification of fault types in fault-tolerant quantum computation consists of three fundamental types:
Space-fault: A Pauli error that occurs on a qubit.
Time-fault: A measurement outcome that is flipped.
Initialization fault: A qubit that starts in the wrong state (equivalent to a space-fault at time 0).
There are exactly \(3\) fault types.
This holds by reflexivity since the type has exactly three constructors: space, time, and initialization.
A function that determines whether a fault type is equivalent to a space-fault for counting purposes:
\(\texttt{space} \mapsto \texttt{true}\)
\(\texttt{initialization} \mapsto \texttt{true}\)
\(\texttt{time} \mapsto \texttt{false}\)
Space faults satisfy \(\texttt{isEquivalentToSpace}(\texttt{space}) = \texttt{true}\).
This holds by reflexivity from the definition.
Initialization faults satisfy \(\texttt{isEquivalentToSpace}(\texttt{initialization}) = \texttt{true}\).
This holds by reflexivity from the definition.
Time faults satisfy \(\texttt{isEquivalentToSpace}(\texttt{time}) = \texttt{false}\).
This holds by reflexivity from the definition.
The three non-identity single-qubit Pauli operators that can occur as errors:
\(X\): Bit flip
\(Y\): Both bit and phase flip
\(Z\): Phase flip
We exclude \(I\) since it represents “no error”.
There are exactly \(3\) error Pauli types.
This holds by reflexivity since the type has exactly three constructors: \(X\), \(Y\), and \(Z\).
The conversion function from \(\texttt{ErrorPauli}\) to the general \(\texttt{PauliOp}\) type:
For any error Pauli \(e\), we have \(\texttt{toPauliOp}(e) \neq I\).
We consider all cases of \(e \in \{ X, Y, Z\} \). In each case, \(\texttt{toPauliOp}(e)\) equals \(X\), \(Y\), or \(Z\) respectively, none of which equal \(I\). The result follows by simplification.
The function \(\texttt{toPauliOp}\) is injective.
Let \(e_1, e_2\) be error Paulis with \(\texttt{toPauliOp}(e_1) = \texttt{toPauliOp}(e_2)\). We perform case analysis on \(e_1\) and \(e_2\). For each combination where \(e_1 \neq e_2\), the images are distinct Pauli operators, contradicting the assumption. Hence \(e_1 = e_2\).
A space-fault (Pauli error) on an \(n\)-qubit system is a triple \((P, q, t)\) where:
\(P \in \{ X, Y, Z\} \) is the type of Pauli error,
\(q \in \{ 0, \ldots , n-1\} \) is the qubit on which the error occurs,
\(t \in \mathbb {N}\) is the time step at which the error occurs.
Two space faults \(f_1 = (P_1, q_1, t_1)\) and \(f_2 = (P_2, q_2, t_2)\) are at the same location if and only if \(q_1 = q_2\) and \(t_1 = t_2\).
Each space fault has weight \(1\).
For any space fault \(f\), we have \(\texttt{weight}(f) = 1\).
This holds by reflexivity from the definition of weight.
For qubit \(q\) and time step \(t\), \(\texttt{mkX}(q, t) = (X, q, t)\) creates an \(X\) error at that location.
For qubit \(q\) and time step \(t\), \(\texttt{mkY}(q, t) = (Y, q, t)\) creates a \(Y\) error at that location.
For qubit \(q\) and time step \(t\), \(\texttt{mkZ}(q, t) = (Z, q, t)\) creates a \(Z\) error at that location.
For any qubit \(q\) and time step \(t\), \(\texttt{mkX}(q, t).\texttt{pauliType} = X\).
This holds by reflexivity from the definition.
For any qubit \(q\) and time step \(t\), \(\texttt{mkY}(q, t).\texttt{pauliType} = Y\).
This holds by reflexivity from the definition.
For any qubit \(q\) and time step \(t\), \(\texttt{mkZ}(q, t).\texttt{pauliType} = Z\).
This holds by reflexivity from the definition.
A time-fault (measurement error) for a system with \(m\) check operators is a pair \((i, r)\) where:
\(i \in \{ 0, \ldots , m-1\} \) identifies which measurement (check operator) has the error,
\(r \in \mathbb {N}\) is the measurement round (time step) at which the error occurs.
This represents a bit-flip of the classical measurement outcome.
Two time faults \(f_1 = (i_1, r_1)\) and \(f_2 = (i_2, r_2)\) are at the same location if and only if \(i_1 = i_2\) and \(r_1 = r_2\).
Each time fault has weight \(1\).
For any time fault \(f\), we have \(\texttt{weight}(f) = 1\).
This holds by reflexivity from the definition of weight.
For measurement index \(\texttt{idx}\) and round \(r\), \(\texttt{create}(\texttt{idx}, r) = (\texttt{idx}, r)\) creates a measurement error at that location.
For any measurement index \(\texttt{idx}\) and round \(r\), \(\texttt{create}(\texttt{idx}, r).\texttt{measurementIndex} = \texttt{idx}\).
This holds by reflexivity from the definition.
For any measurement index \(\texttt{idx}\) and round \(r\), \(\texttt{create}(\texttt{idx}, r).\texttt{measurementRound} = r\).
This holds by reflexivity from the definition.
An initialization fault on an \(n\)-qubit system is a pair \((P, q)\) where:
\(P \in \{ X, Y, Z\} \) is the type of Pauli error that “corrects” to the wrong state,
\(q \in \{ 0, \ldots , n-1\} \) is the qubit that is wrongly initialized.
This is equivalent to a space-fault at time step \(0\): initializing in the wrong state = perfect initialization followed by an error operator.
An initialization fault \((P, q)\) is converted to an equivalent space fault \((P, q, 0)\) at time \(0\). This formalizes: initializing in the wrong state = perfect initialization + error operator.
For any initialization fault \(f\), \(f.\texttt{toSpaceFault}.\texttt{timeStep} = 0\).
This holds by reflexivity from the definition.
For any initialization fault \(f\), \(f.\texttt{toSpaceFault}.\texttt{pauliType} = f.\texttt{pauliType}\).
This holds by reflexivity from the definition.
For any initialization fault \(f\), \(f.\texttt{toSpaceFault}.\texttt{qubit} = f.\texttt{qubit}\).
This holds by reflexivity from the definition.
Each initialization fault has weight \(1\).
For any initialization fault \(f\), we have \(\texttt{weight}(f) = 1\).
This holds by reflexivity from the definition of weight.
For qubit \(q\), \(\texttt{mkBitFlip}(q) = (X, q)\) creates an initialization fault representing a qubit that should have been \(|0\rangle \) but got \(|1\rangle \).
For qubit \(q\), \(\texttt{mkPhaseFlip}(q) = (Z, q)\) creates an initialization fault representing a qubit that should have been \(|+\rangle \) but got \(|-\rangle \).
A general spacetime fault \(F\) on an \(n\)-qubit system with \(m\) check operators is a pair \((S, T)\) where:
\(S\) is a finite set of space faults (Pauli errors),
\(T\) is a finite set of time faults (measurement errors).
The weight of a spacetime fault collection \(F = (S, T)\) is:
The empty fault is \((\emptyset , \emptyset )\), representing no errors.
The number of space faults in \(F = (S, T)\) is \(|S|\).
The number of time faults in \(F = (S, T)\) is \(|T|\).
The empty fault has weight \(0\).
By the definitions of empty and weight, we have \(|\emptyset | + |\emptyset | = 0 + 0 = 0\). This follows by simplification.
The empty fault has no space faults.
By the definitions, \(|\emptyset | = 0\). This follows by simplification.
The empty fault has no time faults.
By the definitions, \(|\emptyset | = 0\). This follows by simplification.
For any spacetime fault \(F\), \(|F| = \texttt{numSpaceFaults}(F) + \texttt{numTimeFaults}(F)\).
This holds by reflexivity from the definitions.
For any spacetime fault \(F\), \(0 \le |F|\).
This follows since the weight is a sum of cardinalities, which are natural numbers.
The union of two spacetime faults \(F_1 = (S_1, T_1)\) and \(F_2 = (S_2, T_2)\) is:
For any spacetime faults \(F_1\) and \(F_2\):
By the definition of union and weight, we need to show:
We have \(|S_1 \cup S_2| \le |S_1| + |S_2|\) and \(|T_1 \cup T_2| \le |T_1| + |T_2|\) by the standard bound on cardinality of unions. Adding these inequalities and rearranging by ring arithmetic gives the result.
For disjoint spacetime faults \(F_1 = (S_1, T_1)\) and \(F_2 = (S_2, T_2)\) (i.e., \(S_1 \cap S_2 = \emptyset \) and \(T_1 \cap T_2 = \emptyset \)):
By the definition of union and weight, and the fact that for disjoint sets \(|A \cup B| = |A| + |B|\), we have:
Rearranging by ring arithmetic gives \((|S_1| + |T_1|) + (|S_2| + |T_2|) = |F_1| + |F_2|\).
Adding a single space fault \(f\) to a spacetime fault \(F = (S, T)\) gives:
Adding a single time fault \(f\) to a spacetime fault \(F = (S, T)\) gives:
If \(f \notin S\) for \(F = (S, T)\), then:
By the definition of addSpaceFault and weight, and using the fact that inserting a new element increases cardinality by \(1\), we have \(|S \cup \{ f\} | = |S| + 1\) when \(f \notin S\). Thus the weight becomes \((|S| + 1) + |T| = (|S| + |T|) + 1 = |F| + 1\) by ring arithmetic.
If \(f \notin T\) for \(F = (S, T)\), then:
By the definition of addTimeFault and weight, and using the fact that inserting a new element increases cardinality by \(1\), we have \(|T \cup \{ f\} | = |T| + 1\) when \(f \notin T\). Thus the weight becomes \(|S| + (|T| + 1) = (|S| + |T|) + 1 = |F| + 1\) by ring arithmetic.
A single-space-fault collection for fault \(f\) is \((\{ f\} , \emptyset )\).
A single-time-fault collection for fault \(f\) is \((\emptyset , \{ f\} )\).
A single space fault has weight \(1\): \(|\texttt{singleSpace}(f)| = 1\).
By the definitions, \(|\{ f\} | + |\emptyset | = 1 + 0 = 1\). This follows by simplification.
A single time fault has weight \(1\): \(|\texttt{singleTime}(f)| = 1\).
By the definitions, \(|\emptyset | + |\{ f\} | = 0 + 1 = 1\). This follows by simplification.
A fault-tolerant code with threshold \(t\) can correct a spacetime fault collection \(F\) if \(|F| \le t\).
The correctable property is monotone: if \(F_1 \subseteq F_2\) (meaning \(S_1 \subseteq S_2\) and \(T_1 \subseteq T_2\)) and \(F_2\) is correctable, then \(F_1\) is correctable.
Assume \(|F_2| \le t\). Since \(S_1 \subseteq S_2\), we have \(|S_1| \le |S_2|\). Similarly, \(|T_1| \le |T_2|\). Therefore:
The result follows by integer arithmetic.
The empty fault is always correctable: for any threshold \(t\), \(|\texttt{empty}| \le t\).
By the empty weight theorem, \(|\texttt{empty}| = 0 \le t\) for any \(t \ge 0\). This follows by simplification.
For a Pauli string \(P\) on \(n\) qubits, the set of non-identity qubits is:
The number of non-identity qubits equals the weight:
This holds by reflexivity since both are defined as the cardinality of the set of qubits where the Pauli string is not the identity.
Space faults and time faults are disjoint by type: \(\texttt{space} \neq \texttt{time}\).
This is verified by computation (decide tactic).
For an initialization fault \(f\), the weight of its equivalent space fault equals its own weight:
Both weights are defined to be \(1\). This follows by simplification using the weight definitions.
For an initialization fault \(f\):
This holds by reflexivity from the definition of space fault weight.
Weight is additive for disjoint fault collections: if \(S_1 \cap S_2 = \emptyset \) and \(T_1 \cap T_2 = \emptyset \), then:
This follows directly from the weight_union_disjoint theorem.
If \(|F| = 0\), then \(F = (\emptyset , \emptyset )\).
Let \(F = (S, T)\) with \(|S| + |T| = 0\). Since cardinalities are non-negative, we must have \(|S| = 0\) and \(|T| = 0\) (by integer arithmetic). By the characterization of empty finite sets via cardinality, \(S = \emptyset \) and \(T = \emptyset \).
Two spacetime faults \(F_1 = (S_1, T_1)\) and \(F_2 = (S_2, T_2)\) are equal if and only if \(S_1 = S_2\) and \(T_1 = T_2\).
We destruct both \(F_1\) and \(F_2\) into their components. Given \(S_1 = S_2\) and \(T_1 = T_2\), we substitute these equalities to conclude \(F_1 = F_2\) by reflexivity.
If \(|F| {\gt} 0\), then at least one fault exists: \(S \neq \emptyset \) or \(T \neq \emptyset \).
Assume \(0 {\lt} |F| = |S| + |T|\). For contradiction, suppose both \(S = \emptyset \) and \(T = \emptyset \). Then \(|S| = 0\) and \(|T| = 0\), so \(|F| = 0\), contradicting \(0 {\lt} |F|\).
The total number of faults is defined as the weight: \(\texttt{totalFaults}(F) = |F|\).
\(\texttt{totalFaults}(F) = |F|\).
This holds by reflexivity from the definition.
\(\texttt{empty}.\texttt{spaceFaults} = \emptyset \).
This holds by reflexivity from the definition of empty.
\(\texttt{empty}.\texttt{timeFaults} = \emptyset \).
This holds by reflexivity from the definition of empty.
1.11 Detector (Definition 12)
A detector is a collection of state initializations and measurements that yield a deterministic result in the absence of faults.
Formally, a detector \(D\) consists of:
A set of qubit initializations (each in a known state)
A set of measurements (each of a known observable)
A parity constraint: the product of measurement outcomes must equal a fixed value (typically \(+1\))
Detector violation: A spacetime fault \(F\) violates detector \(D\) if \(F\) causes the parity constraint of \(D\) to fail.
Syndrome: The syndrome of a spacetime fault \(F\) is the set of all detectors violated by \(F\):
1.11.1 Initialization States
A known initial state for a qubit. In quantum error correction, qubits are typically initialized in:
Computational basis: \(|0\rangle \) or \(|1\rangle \)
Hadamard basis: \(|+\rangle \) or \(|-\rangle \)
Formally, this is an inductive type with four constructors:
\(\mathtt{zero}\): the \(|0\rangle \) state
\(\mathtt{one}\): the \(|1\rangle \) state
\(\mathtt{plus}\): the \(|+\rangle = (|0\rangle + |1\rangle )/\sqrt{2}\) state
\(\mathtt{minus}\): the \(|-\rangle = (|0\rangle - |1\rangle )/\sqrt{2}\) state
There are exactly 4 initialization states:
This holds by reflexivity, as the Fintype instance enumerates exactly the four constructors.
A function that determines whether an initialization state is in the computational basis:
A function that determines whether an initialization state is in the Hadamard basis:
The parity of an initialization state, encoded as an element of \(\mathbb {Z}/2\mathbb {Z}\):
1.11.2 Measurement Observables
A measurement observable for a single qubit. Standard basis measurements in QEC are:
\(Z\)-basis: measures in computational basis (eigenvalues \(\pm 1\))
\(X\)-basis: measures in Hadamard basis (eigenvalues \(\pm 1\))
Formally, this is an inductive type with two constructors: \(\mathtt{Z}\) and \(\mathtt{X}\).
There are exactly 2 measurement bases:
This holds by reflexivity, as the Fintype instance enumerates exactly the two constructors.
1.11.3 Qubit Initialization in a Detector
A single qubit initialization in a detector, specifying which qubit is initialized and in what state. The structure consists of:
\(\mathtt{qubit} : \mathrm{Fin}(n)\) – the qubit being initialized
\(\mathtt{state} : \mathtt{InitState}\) – the initial state
\(\mathtt{timeStep} : \mathtt{TimeStep}\) – the time step of initialization (typically 0)
Two initializations \(i_1, i_2\) are on the same qubit if \(i_1.\mathtt{qubit} = i_2.\mathtt{qubit}\).
1.11.4 Single Qubit Measurement in a Detector
A single qubit measurement in a detector, specifying which qubit is measured, in what basis, and when. The structure consists of:
\(\mathtt{qubit} : \mathrm{Fin}(n)\) – the qubit being measured
\(\mathtt{basis} : \mathtt{MeasBasis}\) – the measurement basis
\(\mathtt{timeStep} : \mathtt{TimeStep}\) – the time step of measurement
Two measurements \(m_1, m_2\) are at the same location if:
1.11.5 Detector Structure
A detector is a collection of initializations and measurements with a parity constraint. In the absence of faults, the product of measurement outcomes equals the expected parity.
We use \(\mathbb {Z}/2\mathbb {Z}\) for parity: \(0\) represents \(+1\) (even parity), \(1\) represents \(-1\) (odd parity).
The structure consists of:
\(\mathtt{initializations} : \mathrm{Finset}(\mathtt{QubitInit}(n))\) – the set of qubit initializations
\(\mathtt{measurements} : \mathrm{Finset}(\mathtt{SingleMeasurement}(n))\) – the set of measurements
\(\mathtt{expectedParity} : \mathbb {Z}/2\mathbb {Z}\) – the expected parity (\(0\) for \(+1\), \(1\) for \(-1\))
The number of initializations in a detector \(D\):
The number of measurements in a detector \(D\):
A detector with no components (trivially satisfied):
The trivial detector has no initializations:
By simplification using the definitions of \(\mathtt{trivial}\) and \(\mathtt{numInits}\), the initializations set is empty, so its cardinality is 0.
The trivial detector has no measurements:
By simplification using the definitions of \(\mathtt{trivial}\) and \(\mathtt{numMeasurements}\), the measurements set is empty, so its cardinality is 0.
The trivial detector has expected parity \(0\) (i.e., \(+1\)):
This holds by reflexivity from the definition of the trivial detector.
The qubits involved in a detector (union of initialized and measured qubits):
A detector is non-trivial if it has at least one component:
1.11.6 Effect of Faults on Measurements
A single-qubit Pauli error affects a measurement outcome according to:
An \(X\) or \(Y\) error flips a \(Z\)-basis measurement
A \(Z\) or \(Y\) error flips an \(X\)-basis measurement
Formally:
An \(X\) error flips a \(Z\)-basis measurement:
This holds by reflexivity from the definition of \(\mathtt{pauliFlipsMeasurement}\).
A \(Z\) error flips an \(X\)-basis measurement:
This holds by reflexivity from the definition of \(\mathtt{pauliFlipsMeasurement}\).
A \(Y\) error flips both \(Z\)-basis and \(X\)-basis measurements:
Both claims hold by reflexivity from the definition of \(\mathtt{pauliFlipsMeasurement}\).
1.11.7 Counting Parity Flips
Count how many times space faults flip a specific measurement’s outcome. A space fault flips the measurement if:
It affects the same qubit
It occurs at or before the measurement time (and after initialization)
The Pauli type anticommutes with the measurement basis
Formally:
Count time faults that affect a measurement at the same location. In this simplified model, we count all time faults:
1.11.8 Parity Calculation
The total parity flip induced by a spacetime fault on a detector’s measurements. This is the sum (mod 2) of:
Space fault flips on each measurement
Time fault flips on each measurement
The detector is violated if this differs from 0. Formally:
The observed parity when fault \(F\) occurs, starting from expected parity:
1.11.9 Detector Violation
A spacetime fault \(F\) violates detector \(D\) if \(F\) causes the parity constraint to fail. This happens when the observed parity differs from the expected parity, i.e., when \(\mathtt{parityFlip}\) is non-zero:
Violation is equivalent to observed parity differing from expected:
We prove both directions:
\((\Rightarrow )\): Assume \(\mathtt{parityFlip}(F, D) \neq 0\). Suppose for contradiction that \(\mathtt{observedParity}(F, D) = D.\mathtt{expectedParity}\), i.e., \(D.\mathtt{expectedParity} + \mathtt{parityFlip}(F, D) = D.\mathtt{expectedParity}\). Then \(\mathtt{parityFlip}(F, D) = D.\mathtt{expectedParity} + \mathtt{parityFlip}(F, D) - D.\mathtt{expectedParity} = 0\), a contradiction.
\((\Leftarrow )\): Assume \(\mathtt{observedParity}(F, D) \neq D.\mathtt{expectedParity}\). Suppose for contradiction that \(\mathtt{parityFlip}(F, D) = 0\). Then \(\mathtt{observedParity}(F, D) = D.\mathtt{expectedParity} + 0 = D.\mathtt{expectedParity}\), contradicting our assumption.
The empty fault never violates any detector:
By unfolding the definitions of \(\mathtt{violates}\) and \(\mathtt{parityFlip}\), we need to show that the parity flip is zero. Since the empty fault has empty space faults and empty time faults, \(\mathtt{countSpaceFlips}(\emptyset , m) = 0\) for all measurements \(m\), and \(|\emptyset | = 0\). Thus the parity flip is \(0 + 0 = 0\), so the detector is not violated.
1.11.10 Syndrome Definition
The syndrome of a spacetime fault \(F\) is the set of all detectors violated by \(F\):
We represent this as a predicate since the set of all detectors is not finite in general.
The syndrome as a finite set given a finite set of detectors:
The syndrome finset is a subset of the detector set:
This follows directly from the fact that the syndrome finset is defined as a filter of the detector set, and any filter is a subset of the original set.
A detector is in the syndrome finset iff it is in the detector set and is violated:
By simplification using the definition of \(\mathtt{syndromeFinset}\) as a filtered set.
The syndrome of the empty fault is empty:
By extensionality, a detector is in the syndrome finset iff it is violated by the empty fault. But by Theorem 1273, the empty fault never violates any detector, so the syndrome finset is empty.
1.11.11 Syndrome Weight
The weight of a syndrome is the number of violated detectors:
The empty fault has zero syndrome weight:
By simplification using the definition of \(\mathtt{syndromeWeight}\) and Theorem 1278, the syndrome finset of the empty fault is empty, so its cardinality is 0.
Syndrome weight is bounded by the number of detectors:
Since the syndrome finset is a subset of the detector set by Theorem 1276, its cardinality is at most the cardinality of the detector set.
1.11.12 Detector Properties
Two faults have the same syndrome if they violate exactly the same detectors:
Same syndrome is reflexive:
For any detector \(D\), \(\mathtt{violates}(F, D) \Leftrightarrow \mathtt{violates}(F, D)\) holds by reflexivity of \(\Leftrightarrow \).
Same syndrome is symmetric:
Let \(h : \mathtt{sameSyndrome}(F_1, F_2)\). For any detector \(D\), we have \(\mathtt{violates}(F_1, D) \Leftrightarrow \mathtt{violates}(F_2, D)\). By symmetry of \(\Leftrightarrow \), we get \(\mathtt{violates}(F_2, D) \Leftrightarrow \mathtt{violates}(F_1, D)\).
Same syndrome is transitive:
Let \(h_1 : \mathtt{sameSyndrome}(F_1, F_2)\) and \(h_2 : \mathtt{sameSyndrome}(F_2, F_3)\). For any detector \(D\), we have \(\mathtt{violates}(F_1, D) \Leftrightarrow \mathtt{violates}(F_2, D)\) and \(\mathtt{violates}(F_2, D) \Leftrightarrow \mathtt{violates}(F_3, D)\). By transitivity of \(\Leftrightarrow \), we get \(\mathtt{violates}(F_1, D) \Leftrightarrow \mathtt{violates}(F_3, D)\).
Same syndrome gives the same syndrome finset:
By extensionality, we show that a detector is in one syndrome finset iff it is in the other. Using Theorem 1277, this reduces to showing that membership and violation conditions are equivalent. Since \(h : \mathtt{sameSyndrome}(F_1, F_2)\) gives us \(\mathtt{violates}(F_1, D) \Leftrightarrow \mathtt{violates}(F_2, D)\) for all \(D\), the result follows.
1.11.13 Helper Lemmas
The number of space flips is bounded by the number of space faults:
Since \(\mathtt{countSpaceFlips}\) counts elements of a filtered subset of \(S\), and any filter has cardinality at most the cardinality of the original set, the result follows.
Zero space faults means zero space flips:
By simplification, filtering the empty set gives the empty set, which has cardinality 0.
Parity flip from empty fault is zero:
By simplification using the definitions of \(\mathtt{parityFlip}\) and \(\mathtt{empty}\). The empty fault has empty space faults and empty time faults, so both sums evaluate to 0.
A detector with no measurements has parity flip equal to the time fault count:
By unfolding the definition of \(\mathtt{parityFlip}\) and simplifying, when the measurements set is empty, the sum over measurements is 0, leaving only the time fault contribution.
The trivial detector is never violated by faults with no time faults:
By unfolding the definitions of \(\mathtt{violates}\) and \(\mathtt{parityFlip}\), and simplifying using the facts that the trivial detector has empty measurements and the fault has empty time faults, the parity flip is 0, so the detector is not violated.
Two detectors with the same components and parity are equal:
By case analysis on \(D_1\) and \(D_2\), extracting the structure fields. After substituting the equalities \(hi\), \(hm\), and \(hp\), the two detectors are definitionally equal.
The syndrome finset is monotone in the detector set:
Let \(D \in \mathtt{syndromeFinset}(F, D_1)\). By the definition of syndrome finset, \(D \in D_1\) and \(\mathtt{violates}(F, D)\). Since \(D_1 \subseteq D_2\), we have \(D \in D_2\). Combined with the violation condition, \(D \in \mathtt{syndromeFinset}(F, D_2)\).
Syndrome weight is monotone in the detector set:
By Theorem 1293, \(\mathtt{syndromeFinset}(F, D_1) \subseteq \mathtt{syndromeFinset}(F, D_2)\). Since cardinality is monotone with respect to subset inclusion, the result follows.
A time region for the gauging procedure consists of:
A start time \(t_i\) of code deformation,
An end time \(t_o\) of code deformation,
A validity condition: \(t_i {\lt} t_o\) (deformation has positive duration).
Given a time region \(R\) with boundaries \(t_i\) and \(t_o\), we define the following predicates for a time \(t\):
\(\texttt{isBefore}(t)\): \(t {\lt} t_i\) (before code deformation),
\(\texttt{isDuring}(t)\): \(t_i {\lt} t {\lt} t_o\) (during code deformation),
\(\texttt{isAfter}(t)\): \(t {\gt} t_o\) (after code deformation),
\(\texttt{isStart}(t)\): \(t = t_i\) (at start boundary),
\(\texttt{isEnd}(t)\): \(t = t_o\) (at end boundary).
For any time region \(R\) and time \(t\), exactly one of the following holds:
We proceed by case analysis on the relationship between \(t\) and the boundaries \(t_i\), \(t_o\). If \(t {\lt} t_i\), then \(\texttt{isBefore}(t)\) holds. Otherwise, \(t \geq t_i\). If \(t = t_i\), then \(\texttt{isStart}(t)\) holds. Otherwise, \(t {\gt} t_i\). In this case, if \(t {\lt} t_o\), then \(\texttt{isDuring}(t)\) holds. Otherwise, \(t \geq t_o\). If \(t = t_o\), then \(\texttt{isEnd}(t)\) holds. Otherwise, \(t {\gt} t_o\), so \(\texttt{isAfter}(t)\) holds.
The time regions are mutually exclusive:
We verify each conjunction is impossible. If \(\texttt{isBefore}(t)\) and \(\texttt{isStart}(t)\), then \(t {\lt} t_i\) and \(t = t_i\), giving \(t_i {\lt} t_i\), a contradiction by irreflexivity. If \(\texttt{isBefore}(t)\) and \(\texttt{isDuring}(t)\), then \(t {\lt} t_i\) and \(t_i {\lt} t\), contradicting asymmetry of \({\lt}\). If \(\texttt{isStart}(t)\) and \(\texttt{isDuring}(t)\), then \(t = t_i\) and \(t_i {\lt} t\), giving \(t_i {\lt} t_i\). If \(\texttt{isDuring}(t)\) and \(\texttt{isEnd}(t)\), then \(t {\lt} t_o\) and \(t = t_o\), giving \(t_o {\lt} t_o\). If \(\texttt{isDuring}(t)\) and \(\texttt{isAfter}(t)\), then \(t {\lt} t_o\) and \(t {\gt} t_o\), contradicting asymmetry.
The parity value type is \(\mathbb {Z}/2\mathbb {Z}\), where \(0\) represents \(+1\) (no flip) and \(1\) represents \(-1\) (flip).
A measurement outcome is an element of \(\mathbb {Z}/2\mathbb {Z}\), where \(0\) represents the \(+1\) outcome and \(1\) represents the \(-1\) outcome.
The XOR parity of two measurement outcomes \(m_1\) and \(m_2\) is their sum in \(\mathbb {Z}/2\mathbb {Z}\):
For all measurement outcomes \(m_1, m_2\):
By definition \(\texttt{xorParity}(m_1, m_2) = m_1 + m_2\) and \(\texttt{xorParity}(m_2, m_1) = m_2 + m_1\). This follows by ring arithmetic since addition in \(\mathbb {Z}/2\mathbb {Z}\) is commutative.
For all measurement outcomes \(m_1, m_2, m_3\):
By definition, the left side equals \((m_1 + m_2) + m_3\) and the right side equals \(m_1 + (m_2 + m_3)\). This follows by ring arithmetic from associativity of addition.
For any measurement outcome \(m\):
By definition, \(\texttt{xorParity}(m, m) = m + m\). In \(\mathbb {Z}/2\mathbb {Z}\), \(m + m = 0\) for all \(m\).
For any measurement outcome \(m\):
By definition, \(\texttt{xorParity}(m, 0) = m + 0 = m\) by ring arithmetic.
An operator type classifies the observable involved in a detector:
\(\texttt{originalCheck}(j)\): Original stabilizer check \(s_j\),
\(\texttt{gaussLaw}(v)\): Gauss law operator \(A_v\),
\(\texttt{flux}(p)\): Flux operator \(B_p\),
\(\texttt{deformedCheck}(j)\): Deformed check \(\tilde{s}_j\),
\(\texttt{edgeZ}(e)\): Single-qubit \(Z\) measurement on edge \(e\).
A detector time type classifies when measurements occur:
\(\texttt{bulk}\): Repeated measurement of same observable at \(t-1/2\) and \(t+1/2\),
\(\texttt{initialBoundary}\): Initialization at \(t_i - 1/2\), first measurement at \(t_i + 1/2\),
\(\texttt{finalBoundary}\): Last measurement at \(t_o - 1/2\), readout at \(t_o + 1/2\).
A bulk detector specification for \(n\) qubits consists of:
A support set \(S \subseteq \{ 0, \ldots , n-1\} \) (the observable being measured),
A first measurement time \(t_1\) (at \(t - 1/2\)),
A second measurement time \(t_2\) (at \(t + 1/2\)),
A consecutiveness condition: \(t_2 = t_1 + 1\).
For any measurement outcome \(m\):
This is the algebraic fact underlying bulk detectors: in error-free projective measurement, measuring the same observable twice on the same state gives identical outcomes, so \(m(t) \oplus m(t+1) = 0\).
This follows directly from the fact that \(\texttt{xorParity}(m, m) = m + m = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
The bulk detector parity of two measurement outcomes \(m_1\) and \(m_2\) is:
For measurement outcomes \(m_1, m_2\):
(\(\Rightarrow \)) Assume \(m_1 + m_2 = 0\). Then \((m_1 + m_2) + m_2 = 0 + m_2\). Using associativity, \(m_1 + (m_2 + m_2) = m_2\). Since \(m_2 + m_2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), we get \(m_1 + 0 = m_2\), hence \(m_1 = m_2\).
(\(\Leftarrow \)) Assume \(m_1 = m_2\). Then \(\texttt{bulkDetectorParity}(m_1, m_2) = m_2 + m_2 = 0\).
The \(Z\) eigenvalue on \(|0\rangle \) is \(+1\), represented as \(0\) in \(\mathbb {Z}/2\mathbb {Z}\):
This encodes the eigenvalue equation \(Z|0\rangle = (+1)|0\rangle \).
The eigenvalue of \(Z\) on \(|0\rangle \) is \(+1\):
This holds by reflexivity of the definition.
For any finite set of edges \(E\), the product of \(Z\) eigenvalues on \(|0\rangle ^{\otimes |E|}\) is \(+1\):
In other words, \((\prod _{e \in E} Z_e)|0\rangle ^{\otimes |E|} = (+1)|0\rangle ^{\otimes |E|}\).
Since \(\texttt{z\_ eigenvalue\_ on\_ zero} = 0\) for each edge, the sum of zeros over any finite set is zero by simplification.
At \(t = t_i\), the detector parity for \(B_p\) is zero:
where the first \(0\) represents the \(|0\rangle \) initialization (implicitly \(+1\)) and the second \(0\) represents \(B_p = \prod _{e \in p} Z_e\) giving \(+1\) on \(|0\rangle ^{\otimes |E|}\).
By simplification, \(\texttt{xorParity}(0, 0) = 0 + 0 = 0\).
For any \(s_j\) outcome, the initial boundary parity for \(\tilde{s}_j\) is zero:
This uses the fact that \(\tilde{s}_j = s_j \cdot Z_\gamma \) and \(Z_\gamma |0\rangle = |0\rangle \) (eigenvalue \(+1\), encoded as \(0\)).
By simplification, \(m_{\tilde{s}} = m_{s_j} + 0 = m_{s_j}\). Then \(\texttt{xorParity}(m_{s_j}, m_{s_j}) = m_{s_j} + m_{s_j} = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
If \(B_p\) outcome equals the product of \(Z_e\) measurements (which holds by definition \(B_p = \prod _{e \in p} Z_e\)), then the final boundary parity is zero:
Assuming \(m_{B_p} = m_{\prod Z_e}\), we rewrite and apply \(\texttt{xorParity}(m, m) = 0\).
For measurement outcomes satisfying \(m_{\tilde{s}} = m_{s_j} + m_{Z_\gamma }\) (from \(\tilde{s}_j = s_j \cdot Z_\gamma \)), the three-way parity is zero:
Substituting \(m_{\tilde{s}} = m_{s_j} + m_{Z_\gamma }\):
using \(m + m = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
An elementary detector is a generator of the detector group, consisting of:
An operator type (what observable is measured),
A time step,
A time type (bulk or boundary).
A detector configuration specifies the detector generating set:
A time region with boundaries \(t_i\) and \(t_o\),
The number of original checks,
The number of vertices (Gauss law operators),
The number of cycles/plaquettes (flux operators).
The set of bulk detectors for original checks at time \(t\) (for \(t {\lt} t_i\) or \(t {\gt} t_o\)) consists of:
The set of bulk detectors during deformation at time \(t\) (for \(t_i {\lt} t {\lt} t_o\)) consists of:
Gauss law detectors: \(\{ (A_v, t, \texttt{bulk}) : v \in \{ 0, \ldots , \texttt{numVertices} - 1\} \} \)
Flux detectors: \(\{ (B_p, t, \texttt{bulk}) : p \in \{ 0, \ldots , \texttt{numCycles} - 1\} \} \)
Deformed check detectors: \(\{ (\tilde{s}_j, t, \texttt{bulk}) : j \in \{ 0, \ldots , \texttt{numOriginalChecks} - 1\} \} \)
The set of initial boundary detectors at \(t = t_i\) consists of:
\(B_p\) initial boundary: \(\{ (B_p, t_i, \texttt{initialBoundary}) : p \in \{ 0, \ldots , \texttt{numCycles} - 1\} \} \)
\(\tilde{s}_j\) initial boundary: \(\{ (\tilde{s}_j, t_i, \texttt{initialBoundary}) : j \in \{ 0, \ldots , \texttt{numOriginalChecks} - 1\} \} \)
The set of final boundary detectors at \(t = t_o\) consists of:
\(B_p\) final boundary: \(\{ (B_p, t_o, \texttt{finalBoundary}) : p \in \{ 0, \ldots , \texttt{numCycles} - 1\} \} \)
\(\tilde{s}_j\) final boundary: \(\{ (\tilde{s}_j, t_o, \texttt{finalBoundary}) : j \in \{ 0, \ldots , \texttt{numOriginalChecks} - 1\} \} \)
For any detector configuration, time \(t\), and original check index \(j {\lt} \texttt{numOriginalChecks}\):
By simplification of set membership in finset image and range. The element \(j\) is in the range since \(j {\lt} \texttt{numOriginalChecks}\), and the image gives the required detector.
For any detector configuration, time \(t\), and vertex index \(v {\lt} \texttt{numVertices}\):
By simplification of set membership. The detector is in the left-most union component (Gauss law detectors), and \(v\) is in the range since \(v {\lt} \texttt{numVertices}\).
For any detector configuration, time \(t\), and cycle index \(p {\lt} \texttt{numCycles}\):
By simplification of set membership. The detector is in the middle union component (flux detectors), and \(p\) is in the range since \(p {\lt} \texttt{numCycles}\).
For any detector configuration, time \(t\), and original check index \(j {\lt} \texttt{numOriginalChecks}\):
By simplification of set membership. The detector is in the rightmost union component (deformed check detectors), and \(j\) is in the range since \(j {\lt} \texttt{numOriginalChecks}\).
For any detector configuration and cycle index \(p {\lt} \texttt{numCycles}\):
By simplification of set membership in the left union component (flux initial boundary detectors).
For any detector configuration and original check index \(j {\lt} \texttt{numOriginalChecks}\):
By simplification of set membership in the right union component (deformed check initial boundary detectors).
For any detector configuration and cycle index \(p {\lt} \texttt{numCycles}\):
By simplification of set membership in the left union component (flux final boundary detectors).
For any detector configuration and original check index \(j {\lt} \texttt{numOriginalChecks}\):
By simplification of set membership in the right union component (deformed check final boundary detectors).
The elementary detector parities are all zero in the error-free case:
Bulk detectors: For all \(m\), \(\texttt{bulkDetectorParity}(m, m) = 0\).
Initial \(B_p\): \(\texttt{xorParity}(0, 0) = 0\).
Initial \(\tilde{s}_j\): For all \(m_{s_j}\), \(\texttt{xorParity}(m_{s_j}, m_{s_j} + 0) = 0\).
Final \(B_p\): If \(m_{B_p} = m_{\prod Z_e}\), then \(\texttt{xorParity}(m_{B_p}, m_{\prod Z_e}) = 0\).
Final \(\tilde{s}_j\): If \(m_{\tilde{s}} = m_{s_j} + m_{Z_\gamma }\), then \(m_{\tilde{s}} + m_{s_j} + m_{Z_\gamma } = 0\).
We verify each part separately:
For bulk detectors, let \(m\) be arbitrary. We apply the bulk detector parity zero lemma.
For initial \(B_p\), this follows from the initial \(B_p\) parity from zero init lemma.
For initial \(\tilde{s}_j\), let \(m_{s_j}\) be arbitrary. We apply the initial \(\tilde{s}\) from zero init lemma.
For final \(B_p\), let \(m_{B_p}\) and \(m_{\prod Z_e}\) be given with \(m_{B_p} = m_{\prod Z_e}\). We apply the final \(B_p\) equals product \(Z_e\) lemma.
For final \(\tilde{s}_j\), let the measurement outcomes be given with \(m_{\tilde{s}} = m_{s_j} + m_{Z_\gamma }\). We apply the final \(\tilde{s}\) parity lemma.
For times before deformation (\(t {\lt} t_i\)) and any original check \(j\), there exists a bulk detector:
We exhibit the detector \((s_j, t, \texttt{bulk})\) and apply the bulk detector exists for original check theorem.
During deformation (\(t_i {\lt} t {\lt} t_o\)), for all vertices, cycles, and original checks, there exist corresponding bulk detectors:
For all \(v {\lt} \texttt{numVertices}\): \(\exists e \in \texttt{bulkDeformationDetectors}\), \(e.\texttt{operatorType} = A_v\).
For all \(p {\lt} \texttt{numCycles}\): \(\exists e \in \texttt{bulkDeformationDetectors}\), \(e.\texttt{operatorType} = B_p\).
For all \(j {\lt} \texttt{numOriginalChecks}\): \(\exists e \in \texttt{bulkDeformationDetectors}\), \(e.\texttt{operatorType} = \tilde{s}_j\).
We verify each part by exhibiting the appropriate detector and applying the corresponding existence theorem.
At the initial boundary \(t_i\), for all cycles and original checks, there exist corresponding boundary detectors:
For all \(p {\lt} \texttt{numCycles}\): \(\exists e \in \texttt{initialBoundaryDetectors}\), \(e.\texttt{operatorType} = B_p\).
For all \(j {\lt} \texttt{numOriginalChecks}\): \(\exists e \in \texttt{initialBoundaryDetectors}\), \(e.\texttt{operatorType} = \tilde{s}_j\).
We verify each part by exhibiting the appropriate detector and applying the corresponding existence theorem.
At the final boundary \(t_o\), for all cycles and original checks, there exist corresponding boundary detectors:
For all \(p {\lt} \texttt{numCycles}\): \(\exists e \in \texttt{finalBoundaryDetectors}\), \(e.\texttt{operatorType} = B_p\).
For all \(j {\lt} \texttt{numOriginalChecks}\): \(\exists e \in \texttt{finalBoundaryDetectors}\), \(e.\texttt{operatorType} = \tilde{s}_j\).
We verify each part by exhibiting the appropriate detector and applying the corresponding existence theorem.
For times after deformation (\(t {\gt} t_o\)) and any original check \(j\), there exists a bulk detector:
We exhibit the detector \((s_j, t, \texttt{bulk})\) and apply the bulk detector exists for original check theorem.
A fault location in spacetime consists of:
A time step,
A qubit index affected.
If consecutive measurements differ (\(m_{\text{before}} \neq m_{\text{after}}\)), the bulk detector parity is nonzero:
Assume \(\texttt{bulkDetectorParity}(m_{\text{before}}, m_{\text{after}}) = 0\). By the bulk parity zero iff equal lemma, this implies \(m_{\text{before}} = m_{\text{after}}\), contradicting \(m_{\text{before}} \neq m_{\text{after}}\).
If initialization and first \(B_p\) measurement outcomes differ, the initial boundary parity is nonzero:
Assume \(\texttt{xorParity}(m_{\text{init}}, m_{B_p}) = 0\). Using the bulk parity zero iff equal lemma (since \(\texttt{xorParity}\)equals \(\texttt{bulkDetectorParity}\)), this implies \(m_{\text{init}} = m_{B_p}\), contradicting the assumption.
If \(B_p\) measurement and product of \(Z_e\) measurements differ, the final boundary parity is nonzero:
Assume \(\texttt{xorParity}(m_{B_p}, m_{\prod Z_e}) = 0\). By the bulk parity zero iff equal lemma, this implies \(m_{B_p} = m_{\prod Z_e}\), contradicting the assumption.
The count of bulk detectors at a single time step before/after deformation:
The count of bulk detectors at a single time step during deformation:
The count of boundary detectors at \(t = t_i\):
The count of boundary detectors at \(t = t_o\):
Boundary times are distinct from interior times:
For the first conjunct: if \(\texttt{isStart}(t_i)\) and \(\texttt{isDuring}(t_i)\), then \(t_i = t_i\) and \(t_i {\lt} t_i\), giving \(t_i {\lt} t_i\), a contradiction by irreflexivity.
For the second conjunct: if \(\texttt{isEnd}(t_o)\) and \(\texttt{isDuring}(t_o)\), then \(t_o = t_o\) and \(t_o {\lt} t_o\), giving \(t_o {\lt} t_o\), a contradiction by irreflexivity.
If \(t_o {\gt} t_i + 1\), then there exists an interior time:
We exhibit \(t = t_i + 1\). Then \(t_i {\lt} t_i + 1\) holds by \(t_i {\lt} t_i + 1\), and \(t_i + 1 {\lt} t_o\) holds by hypothesis.
Every detector time type is one of \(\texttt{bulk}\), \(\texttt{initialBoundary}\), or \(\texttt{finalBoundary}\):
By case analysis on \(tt\): if \(tt = \texttt{bulk}\), the first disjunct holds; if \(tt = \texttt{initialBoundary}\), the second; if \(tt = \texttt{finalBoundary}\), the third.
The three detector time types are mutually exclusive and exhaustive:
By case analysis on \(tt\), each case uniquely satisfies exactly one of the three disjuncts.
[Spacetime Syndromes]
This remark characterizes the syndrome of each type of fault in the spacetime code.
For \(t {\lt} t_i\) and \(t {\gt} t_o\) (before and after code deformation):
Pauli \(X_v\) (or \(Z_v\)) fault at time \(t\): violates \(s_j^t\) for all \(s_j\) that anticommute with \(X_v\) (or \(Z_v\))
\(s_j\)-measurement fault at time \(t + \frac{1}{2}\): violates \(s_j^t\) and \(s_j^{t+1}\)
For \(t_i {\lt} t {\lt} t_o\) (during code deformation):
\(X_v\) fault at time \(t\): violates \(\tilde{s}_j^t\) for anticommuting \(\tilde{s}_j\) (commutes with \(A_v\))
\(Z_v\) fault at time \(t\): violates \(A_v^t\) and \(\tilde{s}_j^t\) for anticommuting \(\tilde{s}_j\)
\(X_e\) fault at time \(t\): violates \(B_p^t\) for all \(p\) containing \(e\), and \(\tilde{s}_j^t\) for anticommuting
\(Z_e\) fault at time \(t\): violates \(A_v^t\) for both \(v \in e\)
Measurement faults: violate detectors at times \(t\) and \(t+1\) for the corresponding check
At boundaries \(t = t_i, t_o\): Initialization/read-out faults are equivalent to Pauli faults and violate the corresponding boundary detectors.
No proof needed for remarks.
A Pauli type classification: either \(X\)-type or \(Z\)-type operator.
The single-site symplectic inner product of two Pauli types. \(X\) and \(Z\) anticommute (product \(= 1\)), while same types commute (product \(= 0\)):
The symplectic product of \(X\) and \(Z\) is \(1\): \(\sigma (X, Z) = 1\).
This holds by reflexivity from the definition of the symplectic product.
The symplectic product of \(Z\) and \(X\) is \(1\): \(\sigma (Z, X) = 1\).
This holds by reflexivity from the definition of the symplectic product.
The symplectic product of \(X\) with itself is \(0\): \(\sigma (X, X) = 0\).
This holds by reflexivity from the definition of the symplectic product.
The symplectic product of \(Z\) with itself is \(0\): \(\sigma (Z, Z) = 0\).
This holds by reflexivity from the definition of the symplectic product.
The symplectic product is symmetric: \(\sigma (p_1, p_2) = \sigma (p_2, p_1)\) for all Pauli types \(p_1, p_2\).
We consider all cases of \(p_1\) and \(p_2\). For each combination \((X,X)\), \((X,Z)\), \((Z,X)\), \((Z,Z)\), the equality holds by reflexivity.
Two operators anticommute if their symplectic product is \(1\):
\(X\) and \(Z\) anticommute as a proposition: \(\text{anticommutes}(X, Z)\).
This holds by reflexivity from the definition of anticommutes.
\(Z\) and \(X\) anticommute as a proposition: \(\text{anticommutes}(Z, X)\).
This holds by reflexivity from the definition of anticommutes.
\(X\) does not anticommute with itself: \(\neg \text{anticommutes}(X, X)\).
Assume \(h\) is a proof of \(\text{anticommutes}(X, X)\). Unfolding the definitions of anticommutes and singleSiteSymplectic, we get \(0 = 1\), which is a contradiction.
\(Z\) does not anticommute with itself: \(\neg \text{anticommutes}(Z, Z)\).
Assume \(h\) is a proof of \(\text{anticommutes}(Z, Z)\). Unfolding the definitions of anticommutes and singleSiteSymplectic, we get \(0 = 1\), which is a contradiction.
A stabilizer check specification consisting of:
A support set: the set of qubits where the check acts non-trivially
A Pauli type: \(X\) or \(Z\)
A time-indexed detector \(s_j^t\) that compares measurements at half-integer times \(t - \frac{1}{2}\) and \(t + \frac{1}{2}\). The detector consists of:
A check being measured
A time index \(t\)
An identifier for the check
The detector value (parity) is: \(\text{outcome}(t-\frac{1}{2}) \oplus \text{outcome}(t+\frac{1}{2})\).
Two detectors are for the same check if they have the same check index.
Two detectors \(d_1\) and \(d_2\) are consecutive if they are for the same check and \(d_2.\text{time} = d_1.\text{time} + 1\).
A Pauli fault at a specific qubit and time, consisting of:
The qubit where the fault occurs
The Pauli type of the fault (\(X\) or \(Z\))
The time of the fault
A fault violates a time-indexed detector if:
The fault qubit is in the detector’s check support
The fault Pauli type anticommutes with the check’s Pauli type
The fault time equals the detector time
An \(X_v\) fault at time \(t\) violates all \(Z\)-type detectors \(s_j^t\) where \(v\) is in \(s_j\)’s support. Formally, if \(v \in \text{support}(s_j)\), \(s_j\) is \(Z\)-type, and the detector is at time \(t\), then the fault \(\langle v, X, t \rangle \) violates the detector.
Unfolding the definition of fault violation, we need to show three conditions: (1) \(v\) is in support (given by hypothesis), (2) \(X\) anticommutes with \(Z\) (follows from the definition after rewriting with the \(Z\)-type hypothesis), and (3) fault time equals detector time (follows from the time hypothesis).
A \(Z_v\) fault at time \(t\) violates all \(X\)-type detectors \(s_j^t\) where \(v\) is in \(s_j\)’s support. Formally, if \(v \in \text{support}(s_j)\), \(s_j\) is \(X\)-type, and the detector is at time \(t\), then the fault \(\langle v, Z, t \rangle \) violates the detector.
Unfolding the definition of fault violation, we need to show three conditions: (1) \(v\) is in support (given by hypothesis), (2) \(Z\) anticommutes with \(X\) (follows from the definition after rewriting with the \(X\)-type hypothesis), and (3) fault time equals detector time (follows from the time hypothesis).
An \(X_v\) fault does NOT violate \(X\)-type detectors (same type operators commute).
Assume the fault violates the detector. Unfolding the definitions with the \(X\)-type hypothesis, the anticommutation condition becomes \(\sigma (X, X) = 1\), i.e., \(0 = 1\), which is a contradiction.
A \(Z_v\) fault does NOT violate \(Z\)-type detectors (same type operators commute).
Assume the fault violates the detector. Unfolding the definitions with the \(Z\)-type hypothesis, the anticommutation condition becomes \(\sigma (Z, Z) = 1\), i.e., \(0 = 1\), which is a contradiction.
Complete characterization: \(X_v\) at time \(t\) violates detector \(s_j^{t'}\) if and only if \(v \in \text{support}(s_j)\), \(s_j\) is \(Z\)-type, and \(t' = t\).
We prove both directions. For the forward direction, assume the fault violates the detector. From the definition, we have \(v\) in support and the time condition. For the Pauli type, we case split: if \(X\)-type then \(\sigma (X,X) = 1\) gives a contradiction; if \(Z\)-type we are done. For the reverse direction, given the three conditions, the support and time conditions are immediate, and \(\sigma (X,Z) = 1\) follows from rewriting with the \(Z\)-type hypothesis.
Complete characterization: \(Z_v\) at time \(t\) violates detector \(s_j^{t'}\) if and only if \(v \in \text{support}(s_j)\), \(s_j\) is \(X\)-type, and \(t' = t\).
We prove both directions. For the forward direction, assume the fault violates the detector. From the definition, we have \(v\) in support and the time condition. For the Pauli type, we case split: if \(X\)-type we are done; if \(Z\)-type then \(\sigma (Z,Z) = 1\) gives a contradiction. For the reverse direction, given the three conditions, the support and time conditions are immediate, and \(\sigma (Z,X) = 1\) follows from rewriting with the \(X\)-type hypothesis.
A measurement fault record: an error in measuring check \(j\) at time \(t + \frac{1}{2}\).
The two detector times affected by a measurement fault at \(t + \frac{1}{2}\):
Detector at time \(t\): compares \(t - \frac{1}{2}\) with \(t + \frac{1}{2}\) (fault is at \(t + \frac{1}{2}\))
Detector at time \(t+1\): compares \(t + \frac{1}{2}\) with \(t + \frac{3}{2}\) (fault is at \(t + \frac{1}{2}\))
Thus \(\text{measurementFaultViolatedTimes}(\text{fault}) = \{ t, t+1\} \).
A measurement fault affects exactly 2 detectors: \(|\text{measurementFaultViolatedTimes}(\text{fault})| = 2\).
Unfolding the definition, we have \(\{ t, t+1\} \). Since \(t \neq t + 1\) (by \(t {\lt} t + 1\)), we have \(t \notin \{ t+1\} \). Therefore the cardinality of \(\{ t, t+1\} \) is \(1 + 1 = 2\) by the insert cardinality formula.
A measurement fault at time \(t\) violates the detector \(s_j^t\): \(t \in \text{measurementFaultViolatedTimes}(\text{fault})\).
Unfolding the definition, \(t\) is the first element inserted, so \(t \in \{ t, t+1\} \) by membership of the inserted element.
A measurement fault at time \(t\) violates the detector \(s_j^{t+1}\): \(t + 1 \in \text{measurementFaultViolatedTimes}(\text{fault})\).
Unfolding the definition, \(t+1 \in \{ t+1\} \) by singleton membership, and \(\{ t+1\} \subseteq \{ t, t+1\} \).
A measurement fault at \(t + \frac{1}{2}\) for check \(j\) violates detector \(s_j^{t'}\) if and only if \(t' = t\) or \(t' = t + 1\).
Unfolding the definition, membership in \(\{ t, t+1\} \) is equivalent to \(t' = t \lor t' = t + 1\) by the characterization of insert and singleton membership.
The parity change from a measurement fault: if the true outcome is \(m\), the reported outcome is \(m + 1\). Each detector using this measurement gets its parity flipped. Specifically, if \(m_{\text{reported}} = m_{\text{true}} + 1\), then:
We simplify and verify both equalities by ring arithmetic: \((m_{\text{before}} + m_{\text{true}} + 1) = (m_{\text{before}} + m_{\text{true}}) + 1\) and \((m_{\text{true}} + 1 + m_{\text{after}}) = (m_{\text{true}} + m_{\text{after}}) + 1\).
The Gauss law operator \(A_v\): an \(X\)-type operator supported on vertex \(v\). Formally, \(A_v\) has support \(\{ v\} \) and Pauli type \(X\).
A flux operator \(B_p\) specification: a \(Z\)-type operator supported on cycle edges. It consists of an index identifying the plaquette and an edge support set.
A flux operator viewed as a check: a \(Z\)-type operator on the flux’s edge support.
\(X_v\) does NOT violate \(A_v^t\). This is the key difference during deformation: \(X\) faults on vertices do NOT trigger Gauss law detectors because both are \(X\)-type.
Assume the fault violates the detector. Unfolding the definitions of fault violation, Gauss law check, anticommutes, and the symplectic product, the anticommutation condition becomes \(\sigma (X, X) = 1\), i.e., \(0 = 1\), which is a contradiction.
During deformation, \(X_v\) violates \(\tilde{s}_j^t\) for all \(\tilde{s}_j\) that contain \(v\) in their support and are \(Z\)-type.
Unfolding the definition of fault violation, we need to verify three conditions: (1) \(v\) is in support (given by hypothesis), (2) anticommutation holds (rewriting with the \(Z\)-type hypothesis gives \(\sigma (X, Z) = 1\)), and (3) the time condition (follows from the hypothesis).
\(Z_v\) fault at time \(t\) violates both:
\(A_v^t\) (the Gauss law detector at \(v\))
All \(X\)-type deformed checks \(\tilde{s}_j^t\) containing \(v\)
We prove both parts. For Part 1 (\(Z_v\) violates \(A_v\)): Unfolding the definitions, \(v \in \{ v\} \) by singleton membership, and \(\sigma (Z, X) = 1\) by definition. For Part 2: Let \(d\) be a detector in the set with \(v\) in support, \(X\)-type, and at time \(t\). Unfolding the definition of fault violation, the support and time conditions are given, and \(\sigma (Z, X) = 1\) follows from rewriting with the \(X\)-type hypothesis.
\(Z_v\) violates \(A_v\) (standalone version): the fault \(\langle v, Z, t \rangle \) violates the Gauss law detector \(A_v^t\).
Unfolding the definitions, \(v \in \{ v\} \) by singleton membership, \(\sigma (Z, X) = 1\) by definition, and the time condition is trivially satisfied.
\(X_e\) fault at time \(t\) violates \(B_p^t\) for all plaquettes \(p\) containing edge \(e\): if \(e \in \text{edgeSupport}(p)\), then the fault \(\langle e, X, t \rangle \) violates the flux detector.
Unfolding the definitions, the three conditions are: (1) \(e\) is in the edge support (given by hypothesis), (2) \(\sigma (X, Z) = 1\) by definition, and (3) the time condition holds by reflexivity.
\(Z_e\) does NOT violate \(B_p\) (both are \(Z\)-type, so they commute).
Assume the fault violates the detector. Unfolding the definitions, the anticommutation condition becomes \(\sigma (Z, Z) = 1\), i.e., \(0 = 1\), which is a contradiction.
An edge with explicit endpoints \(v_1\) and \(v_2\) where \(v_1 \neq v_2\).
The endpoints of an edge as a finite set: \(\{ v_1, v_2\} \).
An edge has exactly 2 endpoints: \(|e.\text{endpoints}| = 2\).
Unfolding the definition, the endpoints are \(\{ v_1, v_2\} \). Since \(v_1 \neq v_2\) (from the edge’s distinctness property), we have \(v_1 \notin \{ v_2\} \). Therefore the cardinality is \(1 + 1 = 2\) by the insert cardinality formula.
The first vertex \(v_1\) is in the endpoints: \(v_1 \in e.\text{endpoints}\).
Unfolding the definition, \(v_1\) is the first element inserted into the set.
The second vertex \(v_2\) is in the endpoints: \(v_2 \in e.\text{endpoints}\).
Unfolding the definition, \(v_2 \in \{ v_2\} \) by singleton membership, and this is a subset of \(\{ v_1, v_2\} \).
\(Z_e\) fault violates \(A_v^t\) for both endpoints \(v \in e\). Specifically:
For any qubit at an endpoint of \(e\), a \(Z\) fault either violates \(A_{v_1}^t\) or \(A_{v_2}^t\)
The endpoint set has exactly 2 elements
We prove both parts. For Part 1: Let \(q\) be a qubit with \(q.\text{val} \in e.\text{endpoints}\). Unfolding the endpoints definition, either \(q.\text{val} = v_1\) or \(q.\text{val} = v_2\). In the first case, we show the fault violates \(A_{v_1}^t\): unfolding definitions, \(q \in \{ v_1\} \) by the equality (using Fin extensionality), and \(\sigma (Z, X) = 1\). The second case is analogous for \(A_{v_2}^t\). Part 2 follows from the edge endpoints cardinality theorem.
An initialization fault on an edge: produces \(|1\rangle \) instead of \(|0\rangle \) at time \(t_i\).
A readout fault on an edge: flips the \(Z\) measurement outcome at time \(t_o\).
An initialization fault has the same syndrome as an \(X\) fault. Physical reasoning: \(|1\rangle = X|0\rangle \), so initializing to \(|1\rangle \) instead of \(|0\rangle \) is indistinguishable from correctly initializing then applying \(X\).
Formally, for any detector \(d\): the conditions (edge qubit in support, \(Z\)-type, at boundary time) hold if and only if the \(X\) fault violates the detector.
For any detector \(d\) in the set, the equivalence follows directly from the symmetric form of the \(X_v\) syndrome characterization theorem.
A readout fault has the same syndrome as a \(Z\) fault. Physical reasoning: flipping a \(Z\) measurement outcome is equivalent to applying \(Z\) before measurement (\(Z\) flips the computational basis).
Formally, for any detector \(d\): the conditions (edge qubit in support, \(X\)-type, at boundary time) hold if and only if the \(Z\) fault violates the detector.
For any detector \(d\) in the set, the equivalence follows directly from the symmetric form of the \(Z_v\) syndrome characterization theorem.
An init fault (equivalent to \(X\) fault) does NOT violate \(A_v\) (both are \(X\)-type, so they commute).
Assume the fault violates the detector. Unfolding the definitions, the anticommutation condition becomes \(\sigma (X, X) = 1\), i.e., \(0 = 1\), which is a contradiction.
A readout fault (equivalent to \(Z\) fault) violates \(A_v\) (Gauss law is \(X\)-type).
Unfolding the definitions, \(v \in \{ v\} \) by singleton membership, and \(\sigma (Z, X) = 1\) by definition.
Classification of time periods:
bulk: \(t {\lt} t_i\) or \(t {\gt} t_o\)
deformation: \(t_i {\lt} t {\lt} t_o\)
boundary: \(t = t_i\) or \(t = t_o\)
Complete classification of spacetime fault syndromes:
\(X\) and \(Z\) anticommute: \(\text{anticommutes}(X, Z) \land \text{anticommutes}(Z, X)\)
Same types commute: \(\neg \text{anticommutes}(X, X) \land \neg \text{anticommutes}(Z, Z)\)
Measurement faults affect exactly 2 detectors
Edge endpoints count equals 2
The theorem follows directly by combining the previously proven results: \(X\)-\(Z\) anticommutation, \(Z\)-\(X\) anticommutation, \(X\)-\(X\) non-anticommutation, \(Z\)-\(Z\) non-anticommutation, the measurement fault two-detector theorem, and the edge endpoints cardinality theorem.
Syndromes add in \(\mathbb {Z}/2\mathbb {Z}\): the same fault twice cancels. For any syndrome \(s \in \mathbb {Z}/2\mathbb {Z}\): \(s + s = 0\).
This follows from the general property that \(s + s = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
Two faults with the same syndrome at the same location cancel: for all \(s \in \mathbb {Z}/2\mathbb {Z}\), \(s + s = 0\).
This follows from the general property that \(s + s = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
[Syndrome Mobility]
This remark describes the fundamental mechanisms by which syndromes can be created, moved, and destroyed in the spacetime picture of quantum error correction.
Syndrome Actions. Syndromes can undergo three types of actions:
Creation: A syndrome is introduced at a spacetime location.
Movement: A syndrome shifts from one location to another.
Destruction: A syndrome is removed (annihilated).
In the spacetime picture, syndromes are conserved locally except at fault locations and boundaries.
Creation/Annihilation.
Pauli errors create syndrome pairs (one at each adjacent time slice).
Measurement errors propagate syndromes forward/backward in time.
Movement.
For \(t {\lt} t_i\) and \(t {\gt} t_o\): Standard syndrome mobility via Pauli strings.
For \(t_i {\lt} t {\lt} t_o\): \(Z_e\) errors on edges form strings that move \(A_v\) syndromes along edge-paths in \(G\).
Condensation at Boundaries.
At \(t = t_i\): \(A_v\) syndromes can be created/destroyed (the \(A_v\) stabilizers start being measured).
At \(t = t_o\): \(A_v\) syndromes can be created/destroyed (the \(A_v\) stabilizers stop being measured).
Propagation through Boundaries. \(B_p\) and \(\tilde{s}_j\) syndromes can propagate through \(t_i\) and \(t_o\) by mapping to vertex-only errors plus \(A_v\) stabilizers.
No proof needed for remarks.
The three fundamental actions that can affect syndromes are defined inductively:
create: Syndrome is created at this location.
move: Syndrome is moved from/to this location.
destroy: Syndrome is destroyed (annihilated) at this location.
The inverse operation on syndrome actions is defined by:
\(\texttt{create}^{-1} = \texttt{destroy}\)
\(\texttt{destroy}^{-1} = \texttt{create}\)
\(\texttt{move}^{-1} = \texttt{move}\)
For any syndrome action \(a\), we have \(a^{-1^{-1}} = a\).
By case analysis on \(a\). For each case (create, move, destroy), the result follows by reflexivity from the definition of inverse.
\(\texttt{move}^{-1} = \texttt{move}\).
This holds by reflexivity from the definition of inverse.
A syndrome event consists of:
An action \(a\) of type SyndromeAction.
A time \(t\) of type TimeStep.
A spatial location identifier \(\ell \in \mathbb {N}\).
A syndrome pair consists of two syndrome events at adjacent times:
A time \(t\) (time of first syndrome).
A spatial location \(\ell \in \mathbb {N}\).
The pair represents syndromes at times \(t\) and \(t+1\) at location \(\ell \).
The two events in a syndrome pair \(p\) with time \(t\) and location \(\ell \) are:
A syndrome pair has exactly two events: \(|p.\mathrm{events}| = 2\).
We unfold the definition of events. The two syndrome events are distinct because they have different times: \(t \neq t + 1\) (since \(t {\lt} t + 1\)). Thus the first event is not in the singleton set containing only the second event. By the cardinality formula for inserting an element not in a set, we get \(|\{ e_1, e_2\} | = 1 + 1 = 2\).
The times at which a syndrome pair \(p\) creates syndromes:
where \(t\) is the time of the pair.
A syndrome pair affects exactly 2 times: \(|p.\mathrm{affectedTimes}| = 2\).
We unfold the definition of affected times. The times \(t\) and \(t+1\) are distinct since \(t {\lt} t+1\). Thus \(t\) is not in the singleton \(\{ t+1\} \). By the cardinality formula for inserting an element not in a set, we get \(|\{ t, t+1\} | = 1 + 1 = 2\).
A Pauli fault creates a syndrome pair at consecutive times. When a Pauli error occurs at time \(t\), it violates the detector at time \(t\) (comparing measurements at \(t-1/2\) and \(t+1/2\)) and the detector at time \(t+1\) (comparing measurements at \(t+1/2\) and \(t+3/2\)). Both detectors use the measurement at \(t+1/2\), which is affected by the fault.
Specifically, for a fault at time \(t\) and location \(\ell \), let \(p = (t, \ell )\) be the syndrome pair. Then:
\(|p.\mathrm{affectedTimes}| = 2\)
\(t \in p.\mathrm{affectedTimes}\)
\((t + 1) \in p.\mathrm{affectedTimes}\)
\(|p.\mathrm{events}| = 2\)
The total syndrome created by a Pauli error has even parity. Two syndromes are created, so the total is \(0 \pmod{2}\):
By computation: \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
A measurement fault consists of:
A time index \(t\) (the measurement is at \(t+1/2\)).
A check index specifying which check is measured.
The detector times affected by a measurement fault at \(t+1/2\):
A measurement fault propagates syndromes. A measurement fault at \(t+1/2\) affects detectors at times \(t\) and \(t+1\):
\(|\mathrm{affectedTimes}| = 2\)
\(t \in \mathrm{affectedTimes}\)
\((t + 1) \in \mathrm{affectedTimes}\)
We unfold the definition of affected times. For membership, \(t\) is the first element inserted and \(t+1\) is in the singleton being extended. For cardinality, since \(t \neq t+1\) (as \(t {\lt} t+1\)), \(t\) is not in \(\{ t+1\} \). By the cardinality formula for inserting an element not in a set, \(|\{ t, t+1\} | = 1 + 1 = 2\).
A graph edge consists of:
A first endpoint \(v_1 \in \mathbb {N}\).
A second endpoint \(v_2 \in \mathbb {N}\).
A proof that the endpoints are distinct: \(v_1 \neq v_2\).
The endpoints of an edge \(e\) are:
An edge has exactly 2 endpoints: \(|e.\mathrm{endpoints}| = 2\).
We unfold the definition. Since \(v_1 \neq v_2\) by the distinctness condition, \(v_1 \notin \{ v_2\} \). By the cardinality formula for inserting an element not in a set, \(|\{ v_1, v_2\} | = 1 + 1 = 2\).
\(v_1 \in e.\mathrm{endpoints}\).
Unfolding the definition, \(v_1\) is the first element inserted into the set.
\(v_2 \in e.\mathrm{endpoints}\).
Unfolding the definition, \(v_2\) is in the singleton \(\{ v_2\} \) which is a subset of \(\{ v_1, v_2\} \).
The commutation relation \([A_v, Z_e]\) is characterized by:
A value of \(1\) (odd) means anticommute, and \(0\) (even) means commute.
\(\mathrm{Ze\_ Av\_ commutation\_ signature}(e, v_1) = 1\).
By unfolding the definition. Since \(v_1 \in e.\mathrm{endpoints}\) (Theorem 1425), the if-condition is true and we return \(1\).
\(\mathrm{Ze\_ Av\_ commutation\_ signature}(e, v_2) = 1\).
By unfolding the definition. Since \(v_2 \in e.\mathrm{endpoints}\) (Theorem 1426), the if-condition is true and we return \(1\).
If \(v \notin e.\mathrm{endpoints}\), then \(\mathrm{Ze\_ Av\_ commutation\_ signature}(e, v) = 0\).
By unfolding the definition. Since \(v \notin e.\mathrm{endpoints}\), the if-condition is false and we return \(0\).
A \(Z_e\) error on edge \(e\) anticommutes with \(A_{v_1}\) and \(A_{v_2}\) (creates syndrome there) and commutes with \(A_v\) for all other \(v\) (no syndrome there):
\(\mathrm{Ze\_ Av\_ commutation\_ signature}(e, v_1) = 1\)
\(\mathrm{Ze\_ Av\_ commutation\_ signature}(e, v_2) = 1\)
For all \(v \notin e.\mathrm{endpoints}\): \(\mathrm{Ze\_ Av\_ commutation\_ signature}(e, v) = 0\)
An edge path in the graph consists of:
A sequence of vertices \([v_0, v_1, \ldots , v_n]\).
A proof that the path has at least 2 vertices (\(n \geq 1\), i.e., at least one edge).
A proof that consecutive vertices are distinct (valid edges): for all \(i\) with \(i + 1 {\lt} n+1\), \(v_i \neq v_{i+1}\).
The start vertex of an edge path \(p\) is the first element of the vertex sequence.
The end vertex of an edge path \(p\) is the last element of the vertex sequence.
The number of edges in an edge path \(p\) is \(|p.\mathrm{vertices}| - 1\).
A path with at least 2 vertices has at least 1 edge: \(p.\mathrm{numEdges} \geq 1\).
Unfolding the definition, \(\mathrm{numEdges} = |p.\mathrm{vertices}| - 1\). Since \(|p.\mathrm{vertices}| \geq 2\) by the path condition, we have \(\mathrm{numEdges} \geq 1\).
The interior vertices of an edge path \(p\) are all vertices except the first and last.
The number of times vertex \(v\) appears in the interior of path \(p\).
The number of edges in the path \(p\) that are incident to vertex \(v\).
The total syndrome contribution at vertex \(v\) from a \(Z_e\) string along the path:
Each edge incident to \(v\) contributes \(1\) to the syndrome (anticommutation).
An interior vertex touched by exactly 2 edges has syndrome 0. If degree \(= 2\), then \(2 \equiv 0 \pmod{2}\), so the syndrome cancels.
By computation: \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
An endpoint touched by exactly 1 edge has syndrome 1: if degree \(= 1\), then \(1 \equiv 1 \pmod{2}\).
By computation: \(1 = 1\) in \(\mathbb {Z}/2\mathbb {Z}\).
For a two-element list \([v_1, v_2]\) with \(v_1 \neq v_2\), consecutive elements at valid indices are distinct.
Let \(i\) be an index with \(i + 1 {\lt} 2\) (the length of the list). Then \(i = 0\). By simplification, \([v_1, v_2][0] = v_1\) and \([v_1, v_2][1] = v_2\), which are distinct by hypothesis.
A simple path (length 2, one edge) from \(v_1\) to \(v_2\) has start vertex \(v_1\) and end vertex \(v_2\).
Both parts follow by reflexivity from the definitions.
\(Z_e\) strings move \(A_v\) syndromes along edge-paths. For a path from \(v_1\) to \(v_2\) with \(v_1 \neq v_2\):
The path has exactly 1 edge.
Start is \(v_1\).
End is \(v_2\).
Syndrome is created at both endpoints (anticommutation): \(1 = 1\).
Two syndromes at the same vertex cancel: \(2 \equiv 0 \pmod{2}\).
All parts follow by reflexivity from the definitions or by computation.
The time region classification relative to deformation boundaries is defined inductively:
beforeStart: Before \(t_i\), standard code, \(A_v\) not measured.
atStart: At \(t = t_i\), start boundary where \(A_v\) measurements begin.
duringDeformation: For \(t_i {\lt} t {\lt} t_o\), during deformation, \(A_v\) is measured.
atEnd: At \(t = t_o\), end boundary where \(A_v\) measurements end.
afterEnd: After \(t_o\), standard code, \(A_v\) not measured.
Whether \(A_v\) stabilizers are measured in a given time region:
Whether a region is a boundary (start or end):
\(\texttt{atStart}.\mathrm{isBoundary} = \text{true}\).
By reflexivity from the definition.
\(\texttt{atEnd}.\mathrm{isBoundary} = \text{true}\).
By reflexivity from the definition.
At boundaries, \(A_v\) syndromes can condense. At a boundary, there is no matching detector on one side. For a region \(r\) with \(r.\mathrm{isBoundary} = \text{true}\):
\(r.\mathrm{AvMeasured} = \text{true}\)
For any initial parity \(p \in \mathbb {Z}/2\mathbb {Z}\), \(p + 1 \neq p\).
For the first part, we do case analysis on the region. Since the region is a boundary, it must be atStart or atEnd, and in both cases \(\mathrm{AvMeasured} = \text{true}\).
For the second part, suppose \(p + 1 = p\) for some \(p\). Then \(1 = p + 1 - p = p - p = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), which is a contradiction.
At the start boundary: \(A_v\) can appear (no detector before):
\(\texttt{atStart}.\mathrm{isBoundary} = \text{true}\)
\(\texttt{beforeStart}.\mathrm{AvMeasured} = \text{false}\)
\(\texttt{atStart}.\mathrm{AvMeasured} = \text{true}\)
All parts follow by reflexivity from the definitions.
At the end boundary: \(A_v\) can disappear (no detector after):
\(\texttt{atEnd}.\mathrm{isBoundary} = \text{true}\)
\(\texttt{atEnd}.\mathrm{AvMeasured} = \text{true}\)
\(\texttt{afterEnd}.\mathrm{AvMeasured} = \text{false}\)
All parts follow by reflexivity from the definitions.
A plaquette is represented by its boundary vertices. For a 2D surface, a plaquette is bounded by a cycle of edges. The structure consists of:
A list of boundary vertices.
A proof that the boundary is a cycle: length \(\geq 3\) and the list returns to its start.
An open string (1-chain) consists of:
A sequence of vertices along the string.
A proof that the string has at least 2 vertices.
A proof that endpoints are distinct (non-trivial string).
The endpoints of an open string \(s\) are the first and last vertices:
An open string has exactly 2 endpoints. This is a fundamental property of 1-dimensional chains: an open string has precisely 2 boundary points (its endpoints). This is \(\partial \gamma \) for a 1-chain \(\gamma \):
Unfolding the definition, the endpoints are the head and last of the vertex list. By the open string condition, these are distinct. Thus the head is not in the singleton containing only the last element. By the cardinality formula for inserting an element not in a set, we get \(|\{ \mathrm{head}, \mathrm{last}\} | = 1 + 1 = 2\).
The \(A_v\) syndromes from a string have even parity. A \(Z_\gamma \) string creates \(A_v\) syndromes at its 2 endpoints. Since \(2 \equiv 0 \pmod{2}\), the parity is even.
By Theorem 1457, \(|s.\mathrm{endpoints}| = 2\). By computation, \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
For a simple square plaquette, the boundary has \(4\) vertices.
\(4 \bmod 2 = 0\).
By computation.
Plaquette boundaries satisfy \(\partial \partial = 0\). For any plaquette \(p\), the boundary \(\partial p\) consists of edges, and each vertex appears an even number of times. This means \(|\{ v : A_v \text{ anticommutes with } B_p\} |\) is even.
If \(n \equiv 0 \pmod{2}\), then \(n = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
If \(n \bmod 2 = 0\), then \(n\) is even. By the characterization of even numbers in \(\mathbb {Z}/2\mathbb {Z}\), even numbers map to \(0\).
\(B_p = \prod _{e \in \partial p} Z_e\) creates \(A_v\) syndromes at vertices in \(\partial p\). Since \(\partial \partial p = \emptyset \) (boundary of boundary is empty), the number of such vertices is even.
At boundaries, these paired \(A_v\) syndromes can condense together, allowing the \(B_p\) syndrome to effectively propagate through.
For \(n\) vertices with \(n \geq 3\) and \(n \equiv 0 \pmod{2}\):
\(B_p\) involves at least 3 vertices (a triangle).
The \(A_v\) syndrome count is even (\(\partial \partial = 0\)).
The first part is the hypothesis \(n \geq 3\). The second part follows from Theorem 1461.
Standard plaquettes (squares, hexagons) have even vertex count: \(4 \bmod 2 =0\) and \(6 \bmod 2 = 0\).
By computation.
\(\tilde{s}_j = s_j \cdot Z_\gamma \) where \(\gamma \) is a string with 2 endpoints. The \(Z_\gamma \) factor creates \(A_v\) syndromes at exactly 2 vertices. These can condense in pairs at boundaries.
For an open string \(s\):
\(|s.\mathrm{endpoints}| = 2\)
\(|s.\mathrm{endpoints}| \equiv 0 \pmod{2}\)
All syndrome mobility mechanisms preserve parity in the bulk:
Pauli creates pairs (even): \(2 \equiv 0 \pmod{2}\).
\(Z_e\) string endpoints (even): \(2 \equiv 0 \pmod{2}\).
Measurement propagates (even): \(2 \equiv 0 \pmod{2}\).
All three parts follow by computation: \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
At boundaries, single syndromes can condense (odd). For any initial parity \(p\):
Suppose \(p + 1 = p\) for some \(p \in \mathbb {Z}/2\mathbb {Z}\). Then \(1 = p + 1 - p = p - p = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), which is a contradiction.
Two syndromes cancel (mod 2 arithmetic):
By computation.
The syndrome action type has exactly 3 elements.
By reflexivity from the definition of the finite type instance.
1.12 Spacetime Logical Fault (Definition 13)
A spacetime logical fault is a collection of space and time faults that:
Does not violate any detector: \(\mathrm{syn}(F) = \emptyset \)
Is not a spacetime stabilizer (see Definition 14)
Intuitively, a spacetime logical fault is an undetectable error that affects the computation result.
1.12.1 Undetectable Faults
A spacetime fault \(F\) is undetectable with respect to a set of detectors \(D\) if it does not violate any detector. Formally:
This means \(\mathrm{syn}(F) = \emptyset \) — the syndrome is empty.
A spacetime fault \(F\) is undetectable if and only if its syndrome weight is zero:
By unfolding the definitions of isUndetectable and syndromeWeight, we have that \(\mathrm{isUndetectable}(F, D)\) holds iff \(\mathrm{syndromeFinset}(F, D) = \emptyset \), and \(\mathrm{syndromeWeight}(F, D) = |\mathrm{syndromeFinset}(F, D)|\). The result follows by the fact that the cardinality of a finite set equals zero if and only if the set is empty.
A spacetime fault \(F\) is undetectable if and only if no detector is violated:
By unfolding the definitions of isUndetectable and syndromeFinset, we have that \(\mathrm{syndromeFinset}(F, D) = \{ d \in D \mid \mathrm{violates}(F, d)\} \). Thus \(\mathrm{syndromeFinset}(F, D) = \emptyset \) if and only if the filter predicate is false for all elements, which by simplification gives the desired equivalence.
The empty spacetime fault is undetectable for any set of detectors \(D\):
By unfolding the definition of isUndetectable, we need to show \(\mathrm{syndromeFinset}(\mathrm{empty}, D) = \emptyset \). This follows directly from the theorem syndrome_empty which states that the syndrome of the empty fault is empty.
1.12.2 Spacetime Logical Fault
A spacetime fault \(F\) is a spacetime logical fault with respect to a stabilizer predicate \(\mathrm{isStabilizer}\) and detectors \(D\) if:
\(F\) is undetectable: \(\mathrm{isUndetectable}(F, D)\)
\(F\) is not a spacetime stabilizer: \(\neg \mathrm{isStabilizer}(F, D)\)
Formally:
The stabilizer predicate determines which undetectable faults act trivially on the computation. Per Definition 14, this involves checking whether the fault can be decomposed into products of code stabilizer generators and matching time fault pairs.
A spacetime logical fault is a structure bundling:
A spacetime fault \(F\)
Proof that \(F\) is undetectable
Proof that \(F\) is not a spacetime stabilizer
The stabilizer predicate is provided as a parameter.
If \(F\) is a spacetime logical fault structure, then its underlying fault satisfies the spacetime logical fault predicate:
This follows directly by constructing the conjunction from \(F.\mathrm{undetectable}\) and \(F.\mathrm{notStabilizer}\).
The weight of a spacetime logical fault \(F\) is the weight of its underlying spacetime fault:
Given a spacetime fault \(F\) satisfying the logical fault predicate, we can construct a spacetime logical fault structure.
For any spacetime logical fault \(F\), its syndrome is empty:
This follows directly from the \(\mathrm{undetectable}\) field of the spacetime logical fault structure.
For any spacetime logical fault \(F\), its syndrome weight is zero:
By rewriting using the equivalence between undetectable and zero syndrome weight (theorem isUndetectable_iff_syndromeWeight_zero), the result follows from \(F.\mathrm{undetectable}\).
For any spacetime logical fault \(F\) and any detector \(d \in D\), the fault does not violate \(d\):
By rewriting using the equivalence between undetectable and no violation (theorem isUndetectable_iff_no_violation), the result follows from \(F.\mathrm{undetectable}\).
1.12.3 Properties of Logical Faults
A fault cannot be both a spacetime stabilizer and a spacetime logical fault:
Assume both \(\mathrm{isStabilizer}(F, D)\) and \(\mathrm{IsSpacetimeLogicalFault}(\mathrm{isStabilizer}, F, D)\) hold. Let \(h_{\mathrm{Stab}}\) denote the former and \(h_{\mathrm{Log}}\) denote the latter. By definition, \(h_{\mathrm{Log}}\) includes \(\neg \mathrm{isStabilizer}(F, D)\), which contradicts \(h_{\mathrm{Stab}}\).
Every undetectable fault is either a spacetime stabilizer or a spacetime logical fault:
Assume \(\mathrm{isUndetectable}(F, D)\). We consider two cases based on whether \(\mathrm{isStabilizer}(F, D)\) holds.
Case 1: If \(\mathrm{isStabilizer}(F, D)\) holds, then the left disjunct is satisfied.
Case 2: If \(\neg \mathrm{isStabilizer}(F, D)\), then by combining with the undetectable hypothesis, we have \(\mathrm{IsSpacetimeLogicalFault}(\mathrm{isStabilizer}, F, D)\), satisfying the right disjunct.
The empty fault is a spacetime logical fault if and only if it is not a stabilizer:
We prove both directions.
(\(\Rightarrow \)): Assume \(\mathrm{IsSpacetimeLogicalFault}(\mathrm{isStabilizer}, \mathrm{empty}, D)\). By definition, this includes \(\neg \mathrm{isStabilizer}(\mathrm{empty}, D)\).
(\(\Leftarrow \)): Assume \(\neg \mathrm{isStabilizer}(\mathrm{empty}, D)\). Combined with the fact that the empty fault is undetectable (theorem empty_isUndetectable), we obtain the logical fault predicate.
1.12.4 Consistency Properties
If the stabilizer predicate includes all undetectable faults, then there are no spacetime logical faults:
Assume the hypothesis \(h: \forall G,\, \mathrm{isUndetectable}(G, D) \Rightarrow \mathrm{isStabilizer}(G, D)\). Suppose for contradiction that \(\mathrm{IsSpacetimeLogicalFault}(\mathrm{isStabilizer}, F, D)\) holds. This gives us \(h_{\mathrm{Undet}}: \mathrm{isUndetectable}(F, D)\) and \(h_{\mathrm{NotStab}}: \neg \mathrm{isStabilizer}(F, D)\). Applying \(h\) to \(F\) and \(h_{\mathrm{Undet}}\) gives \(\mathrm{isStabilizer}(F, D)\), which contradicts \(h_{\mathrm{NotStab}}\).
If the stabilizer predicate is trivially false (i.e., \(\mathrm{isStabilizer} \equiv \bot \)), then every undetectable fault is a spacetime logical fault:
Assume \(\mathrm{isUndetectable}(F, D)\). We need to show \(\mathrm{isUndetectable}(F, D) \land \neg \bot \). The first conjunct is the hypothesis. The second conjunct \(\neg \bot \) holds because assuming \(\bot \) leads to a contradiction.
1.12.5 Fault Distance Motivation
The spacetime fault-distance (Definition 15) will be defined as:
This represents the minimum weight of an undetectable fault pattern that is not equivalent to a spacetime stabilizer.
The existence of a spacetime logical fault with weight \(w\) provides an upper bound on \(d_{\mathrm{ST}}\):
implies \(d_{\mathrm{ST}} \leq w\).
Given a spacetime logical fault \(F\) with \(F.\mathrm{weight} \leq w\), we exhibit the underlying fault \(F.\mathrm{fault}\) as a witness. By the theorem isLogicalFault, \(F.\mathrm{fault}\) satisfies the logical fault predicate, and its weight satisfies the bound by hypothesis.
1.12.6 Helper Lemmas
The weight of a spacetime logical fault is non-negative:
This follows from the fact that natural numbers are non-negative: \(\mathbb {N}.\mathrm{zero\_ le}\).
If there are no detectors, every fault is undetectable:
By unfolding the definitions of isUndetectable and syndromeFinset, filtering the empty set yields the empty set. By simplification, this gives the result.
Two spacetime logical faults with the same underlying fault are equal:
We destruct both \(F\) and \(G\) as structures. After simplification, the hypothesis gives equality of the fault fields. We substitute to make the fault fields definitionally equal, and the proof obligations for the remaining fields are satisfied by reflexivity (since they are proofs of the same propositions about the same fault).
A collection of time faults cancels if for each measurement index \(\mathrm{idx} \in \mathrm{Fin}(m)\), the number of time faults at that index is even:
This captures the condition that measurement errors come in pairs that cancel out.
Time faults in the empty fault set trivially cancel.
Let \(\mathrm{idx}\) be an arbitrary measurement index. By definition, the filter of the empty set over any predicate is empty, so the cardinality is \(0\). Since \(0 = 2 \cdot 0\), we have that \(0\) is even, which proves the claim.
Convert a set of space faults to a StabilizerCheck by accumulating their Pauli operators. The resulting check has:
\(\mathrm{supportX}\): qubits with an odd count of \(X\) or \(Y\) errors
\(\mathrm{supportZ}\): qubits with an odd count of \(Z\) or \(Y\) errors
\(\mathrm{phase} = \text{Phase.one}\) (we only care about Pauli action for stabilizer membership)
This handles the case where multiple errors on the same qubit may cancel.
Empty space faults convert to the identity check.
By the definition of spaceFaultsToCheck and StabilizerCheck.identity, we must show that both supportX and supportZ are empty for the empty fault set. For each qubit \(q\), the filter of the empty set is empty, so the cardinality is \(0\). Since \(0\) is not odd, \(q\) is not in the support. By extensionality applied to both supports, the claim follows.
Space faults form a stabilizer element if their net effect (computed via spaceFaultsToCheck) is in the stabilizer group. This means the fault can be expressed as a product of stabilizer generators, so it acts trivially on the code space.
Empty space faults are always in the stabilizer group (identity is a stabilizer).
Unfolding the definition of spaceFaultsAreStabilizer, we rewrite using spaceFaultsToCheck_empty to reduce to showing that the identity check is a stabilizer element. This follows directly from identity_is_stabilizer.
A spacetime fault acts trivially on the gauging measurement if:
Time faults cancel in pairs (even count at each measurement index)
Space faults form a stabilizer element (product of generators)
This captures condition (ii) of the spacetime stabilizer definition: “Does not affect the result of the gauging measurement procedure.”
The empty fault acts trivially.
Unfolding the definition of actsTriviallyOnMeasurement, we need to show both conjuncts. For the first, let an arbitrary measurement index be given; by the definition of SpaceTimeFault.empty, the time faults are empty, so by simplification, the condition holds trivially. For the second, the result follows directly from spaceFaultsAreStabilizer_empty.
A spacetime stabilizer is a spacetime fault \(F\) that:
Does not violate any detector: \(\mathrm{syn}(F) = \emptyset \) (i.e., isUndetectable)
Acts trivially on the gauging measurement: time faults cancel and space faults form a stabilizer element
These are the “trivial” undetectable faults—errors that cancel out completely.
A spacetime stabilizer is undetectable.
By definition, if \(h : \text{IsSpacetimeStabilizer } C\, F\, \text{detectors}\), then \(h\) is a conjunction and we extract the first component \(h.1\), which is exactly \(\text{isUndetectable } F\, \text{detectors}\).
A spacetime stabilizer acts trivially.
By definition, if \(h : \text{IsSpacetimeStabilizer } C\, F\, \text{detectors}\), then \(h\) is a conjunction and we extract the second component \(h.2\), which is exactly \(\text{actsTriviallyOnMeasurement } C\, F\).
A spacetime stabilizer has time faults that cancel.
By definition, if \(h : \text{IsSpacetimeStabilizer } C\, F\, \text{detectors}\), then \(h.2\) gives actsTriviallyOnMeasurement, and we extract the first component \(h.2.1\), which is timeFaultsCancel.
A spacetime stabilizer has space faults in the stabilizer group.
By definition, if \(h : \text{IsSpacetimeStabilizer } C\, F\, \text{detectors}\), then \(h.2\) gives actsTriviallyOnMeasurement, and we extract the second component \(h.2.2\), which is spaceFaultsAreStabilizer.
A SpacetimeStabilizer is a structure bundling a spacetime fault with proofs that it is a spacetime stabilizer:
A spacetime fault \(F\)
Proof that \(F\) is undetectable (empty syndrome)
Proof that \(F\)’s time faults cancel in pairs
Proof that \(F\)’s space faults are in the stabilizer group
A spacetime stabilizer acts trivially on measurement.
Given a spacetime stabilizer \(S\), we construct the proof of actsTriviallyOnMeasurement as the pair \(\langle S.\text{timeCancel}, S.\text{spaceStabilizer} \rangle \).
A spacetime stabilizer satisfies the IsSpacetimeStabilizer predicate.
Given a spacetime stabilizer \(S\), we construct the proof as the pair \(\langle S.\text{undetectable}, S.\text{trivialAction} \rangle \).
The weight of a spacetime stabilizer \(S\) is the weight of its underlying fault: \(S.\text{weight} = S.\text{fault}.\text{weight}\).
Given a fault \(F\) satisfying IsSpacetimeStabilizer, construct the corresponding SpacetimeStabilizer structure by extracting the components of the proof.
The syndrome of a spacetime stabilizer isempty.
This follows directly from the undetectable field of the spacetime stabilizer structure, which states that \(\text{syndromeFinset } S.\text{fault} \, \text{detectors} = \emptyset \).
A spacetime stabilizer has zero syndrome weight.
We rewrite using isUndetectable_iff_syndromeWeight_zero and apply the undetectable field of the spacetime stabilizer.
A spacetime stabilizer violates no detector.
We rewrite using isUndetectable_iff_no_violation and apply the undetectable field of the spacetime stabilizer.
A fault is a spacetime logical fault (concrete version) if it is undetectable but does NOT act trivially—either the time faults don’t cancel or the space faults are not in the stabilizer group.
Stabilizers and logical faults form a dichotomy of undetectable faults. An undetectable fault is EITHER a stabilizer OR a logical fault, never both.
We proceed by cases on whether \(\text{actsTriviallyOnMeasurement } C\, F\) holds. If it does, then we have the left disjunct: \(\langle h, \text{htriv} \rangle \) proves IsSpacetimeStabilizer. If it does not, then we have the right disjunct: \(\langle h, \text{htriv} \rangle \) proves IsSpacetimeLogicalFaultConcrete where htriv is the negation.
A fault cannot be both a stabilizer and a logical fault.
Assume \(\langle \text{hStab}, \text{hLog} \rangle \) where both predicates hold. From hLog.2 we have \(\neg \text{actsTriviallyOnMeasurement } C\, F\), but from hStab.2 we have \(\text{actsTriviallyOnMeasurement } C\, F\). This is a contradiction.
Stabilizers and logical faults are mutually exclusive and exhaustive for undetectable faults.
Unfolding the definition of Xor’, we proceed by cases on whether \(\text{actsTriviallyOnMeasurement } C\, F\) holds. If it does, then IsSpacetimeStabilizer holds and IsSpacetimeLogicalFaultConcrete cannot hold (since the latter requires \(\neg \text{actsTriviallyOnMeasurement}\)). If it does not, then IsSpacetimeLogicalFaultConcrete holds and IsSpacetimeStabilizer cannot hold.
The three-way classification of spacetime faults:
Detectable (non-empty syndrome)
Undetectable stabilizer (empty syndrome, trivial action)
Undetectable logical fault (empty syndrome, non-trivial action)
We proceed by cases on whether \(\text{isUndetectable } F\, \text{detectors}\) holds. If it does, then by stabilizer_vs_logical_dichotomy, we get the right disjunct (stabilizer or logical fault). If it does not, then we get the left disjunct (detectable).
The empty fault is always a spacetime stabilizer. The empty fault has empty syndrome (no detectors violated), empty time faults (trivially cancel), and empty space faults (identity is in stabilizer group).
We construct the proof as a conjunction. For the first part, we apply empty_isUndetectable. For the second part, we apply actsTrivially_empty.
Construct the empty spacetime stabilizer, consisting of the empty fault with proofs of undetectability, time fault cancellation, and space fault stabilizer membership.
The empty stabilizer has weight \(0\).
By simplification using the definitions of emptyStabilizer and SpacetimeStabilizer.weight, the result follows directly.
A single time fault does not cancel (odd count).
Assume for contradiction that the singleton set \(\{ f\} \) satisfies timeFaultsCancel. Applying this to \(f.\text{measurementIndex}\), we get that the cardinality of the filter is even. By simplification, the filter of a singleton with the matching index has cardinality \(1\). But \(1\) is not even, which is a contradiction.
Two time faults on the same measurement index with different rounds cancel.
Let \(\mathrm{idx}\) be an arbitrary measurement index. We consider two cases. If \(\mathrm{idx} = f_1.\text{measurementIndex}\), then since \(f_1\) and \(f_2\) have the same measurement index (by heq_idx) and are distinct (by hne), the filter contains exactly two elements. Using Finset.card_insert_of_notMem with the fact that \(f_1 \neq f_2\), we get cardinality \(2 = 2 \cdot 1\), which is even. If \(\mathrm{idx}\) is different from both measurement indices, then the filter is empty, so the cardinality is \(0 = 2 \cdot 0\), which is even.
A fault with a single time fault is NOT a stabilizer (because time faults don’t cancel).
Assume for contradiction that \(F\) is a spacetime stabilizer. Then by h.2.1, we have timeFaultsCancel. Rewriting using \(\text{hF} : F.\text{timeFaults} = \{ f\} \), we get that the singleton cancels. But this contradicts single_timeFault_not_cancel.
The minimum weight stabilizer is the empty fault with weight \(0\).
We exhibit emptyStabilizer and note that its weight is \(0\) by reflexivity.
Stabilizer weight is bounded by fault weight.
This holds by reflexivity since \(S.\text{weight} = S.\text{fault}.\text{weight}\) by definition.
The concrete stabilizer predicate is consistent with Def_13’s logical fault: IsSpacetimeLogicalFault (using actsTriviallyOnMeasurement as the stabilizer test) is equivalent to IsSpacetimeLogicalFaultConcrete.
This holds by reflexivity of the definitions.
Connecting to the parameterized version in Def_13: if we instantiate the stabilizer predicate with actsTriviallyOnMeasurement, we get our concrete definitions.
This holds by reflexivity of the definitions.
The weight of a stabilizer is non-negative.
This follows from Nat.zero_le, since weight is a natural number.
Two spacetime stabilizers with the same underlying fault are equal.
We destruct both stabilizers using cases. By simplification, we reduce to showing that the faults are equal. Substituting using hypothesis \(h\), the result follows by reflexivity.
If there are no detectors, every fault with trivial action is a stabilizer.
We construct the proof as a conjunction. For undetectability, we apply isUndetectable_of_empty_detectors. For trivial action, we use the hypothesis htriv.
A fault with no faults at all acts trivially.
Unfolding actsTriviallyOnMeasurement, we construct both conjuncts. For time faults: let an arbitrary index be given; by the hypothesis htime that time faults are empty, simplification shows the condition holds. For space faults: unfolding spaceFaultsAreStabilizer, we rewrite using hspace and spaceFaultsToCheck_empty, then apply identity_is_stabilizer.
A fault with no faults and empty syndrome is a stabilizer.
We construct the proof as \(\langle \text{hund}, \text{actsTrivially\_ of\_ no\_ faults } C\, F\, \text{hspace}\, \text{htime} \rangle \).
A spacetime stabilizer has even time fault counts at each measurement.
We extract \(h.2.1 : \text{timeFaultsCancel}\) and apply it to the given index.
A spacetime stabilizer has space faults in the stabilizer group.
We extract \(h.2.2 : \text{spaceFaultsAreStabilizer}\).
1.13 Spacetime Stabilizer Generators (Lemma 4)
This section formalizes the generating set of local spacetime stabilizers. The generators are classified by time region: before/after code deformation, during code deformation, and at the boundary times \(t_i\) and \(t_o\).
1.13.1 Anticommutation and Check Support
The key constraint for time generators is that measurement faults must be placed on checks that anticommute with the Pauli fault. This captures the requirement “measurement faults on all anticommuting checks \(s_j\) at time \(t + 1/2\)”.
A check anticommutes with an \(X\) error on qubit \(q\) if \(q\) is in the check’s \(Z\)-support. Formally, for a stabilizer check \(\mathsf{check}\) and qubit \(q \in \{ 0, \ldots , n-1\} \):
This follows because \(X\) and \(Z\) anticommute, so an \(X\) error flips a \(Z\)-type measurement.
A check anticommutes with a \(Z\) error on qubit \(q\) if \(q\) is in the check’s \(X\)-support:
A check anticommutes with a \(Y\) error on qubit \(q\) if \(q\) is in exactly one of the \(X\)-support or \(Z\)-support (exclusive or):
A Pauli error \(p\) on qubit \(q\) anticommutes with a check according to the Pauli type:
1.13.2 Anticommuting Check Set
Given a stabilizer code \(C\), a Pauli error type \(p\), and a qubit \(q\), the set of check indices that anticommute with this error is:
This captures “all anticommuting checks \(s_j\)” from the original statement.
1.13.3 Space Generators
A space generator is a stabilizer check operator applied at a specific time. The key property is that a stabilizer element produces no syndrome and acts trivially on the code space.
A space generator consists of:
A time \(t\) at which the check is applied
A set \(\mathsf{supportX} \subseteq \{ 0, \ldots , n-1\} \) of qubits in the \(X\)-support
A set \(\mathsf{supportZ} \subseteq \{ 0, \ldots , n-1\} \) of qubits in the \(Z\)-support
A space generator is converted to space faults by:
For each \(q \in \mathsf{supportX} \setminus \mathsf{supportZ}\): an \(X\) fault at qubit \(q\), time \(t\)
For each \(q \in \mathsf{supportZ} \setminus \mathsf{supportX}\): a \(Z\) fault at qubit \(q\), time \(t\)
For each \(q \in \mathsf{supportX} \cap \mathsf{supportZ}\): a \(Y\) fault at qubit \(q\), time \(t\)
A space generator converts to a spacetime fault with the computed space faults and empty time faults.
The identity space generator at time \(t\) has empty \(X\)-support and empty \(Z\)-support:
The identity space generator produces empty space faults:
By definition, the identity generator has \(\mathsf{supportX} = \emptyset \) and \(\mathsf{supportZ} = \emptyset \). Therefore:
\(\mathsf{supportX} \setminus \mathsf{supportZ} = \emptyset \setminus \emptyset = \emptyset \)
\(\mathsf{supportZ} \setminus \mathsf{supportX} = \emptyset \setminus \emptyset = \emptyset \)
\(\mathsf{supportX} \cap \mathsf{supportZ} = \emptyset \cap \emptyset = \emptyset \)
The union of empty images is empty, so \(\mathrm{toSpaceFaults} = \emptyset \).
Given a stabilizer check and time \(t\), create a space generator:
1.13.4 Time Generators
A time generator consists of a Pauli fault \(P\) at time \(t\), the same Pauli \(P\) at time \(t+1\), and measurement faults on all anticommuting checks at time \(t + 1/2\). The key insight is that the measurement faults must be exactly the checks that anticommute with \(P\).
A time generator for code \(C\) consists of:
A first time \(t_1\)
A qubit \(q \in \{ 0, \ldots , n-1\} \)
A Pauli type \(p \in \{ X, Y, Z\} \)
A set of measurement fault indices
A constraint: the cardinality of measurement faults equals the cardinality of anticommuting check indices
The constraint ensures measurement faults correspond to anticommuting checks.
The second time of a time generator is \(t_2 = t_1 + 1\).
For any time generator \(\mathsf{tg}\), we have \(\mathsf{tg}.t_2 = \mathsf{tg}.t_1 + 1\).
This holds by definition of \(t_2\).
For any time generator \(\mathsf{tg}\), we have \(\mathsf{tg}.t_1 \neq \mathsf{tg}.t_2\).
Since \(t_2 = t_1 + 1\), we have \(t_1 {\lt} t_1 + 1 = t_2\), so \(t_1 \neq t_2\).
The space faults of a time generator consist of the Pauli \(p\) at qubit \(q\) at time \(t_1\), and the same Pauli at time \(t_2\):
The time faults of a time generator are the measurement faults at time \(t_1\):
A time generator converts to a spacetime fault with the computed space faults and time faults.
The space faults of a time generator have exactly two elements:
The set \(\{ (p, q, t_1), (p, q, t_2)\} \) has cardinality 2 if and only if the two elements are distinct. We have \((p, q, t_1) \neq (p, q, t_2)\) because \(t_1 \neq t_2\) (by Theorem 1547). Thus the cardinality is \(1 + 1 = 2\).
1.13.5 Core Cancellation Properties
The fundamental property of time generators is that paired Paulis \(P\) at times \(t\) and \(t+1\) cancel because \(P^2 = I\).
For a time generator \(\mathsf{tg}\) and any qubit \(q\), the count of faults in \(\mathsf{tg}.\mathrm{toSpaceFaults}\) that are \(X\) or \(Y\) type at qubit \(q\) is even (not odd).
We consider cases on whether \(q\) equals \(\mathsf{tg}.\mathsf{qubit}\).
Case \(q \neq \mathsf{tg}.\mathsf{qubit}\): The filter condition \(\mathsf{qubit} = q\) is false for both elements of \(\mathrm{toSpaceFaults}\), so the filtered set is empty and the count is \(0 = 2 \cdot 0\), which is even.
Case \(q = \mathsf{tg}.\mathsf{qubit}\): We further consider cases on \(\mathsf{tg}.\mathsf{pauliType}\):
If \(\mathsf{pauliType} = X\): Both faults pass the filter (\(X\) is \(X\) or \(Y\)). The set \(\{ (X, q, t_1), (X, q, t_2)\} \) has cardinality 2 (since \(t_1 \neq t_2\)), which is even.
If \(\mathsf{pauliType} = Y\): Both faults pass the filter. The count is 2, which is even.
If \(\mathsf{pauliType} = Z\): Neither fault passes the filter (\(Z\) is not \(X\) or \(Y\)). The count is 0, which is even.
In all cases, the count is even.
For a time generator \(\mathsf{tg}\) and any qubit \(q\), the count of faults in \(\mathsf{tg}.\mathrm{toSpaceFaults}\) that are \(Z\) or \(Y\) type at qubit \(q\) is even (not odd).
The proof is symmetric to Theorem 1552. We consider cases on whether \(q\) equals \(\mathsf{tg}.\mathsf{qubit}\).
Case \(q \neq \mathsf{tg}.\mathsf{qubit}\): The filtered set is empty and the count is \(0\), which is even.
Case \(q = \mathsf{tg}.\mathsf{qubit}\): We consider cases on \(\mathsf{tg}.\mathsf{pauliType}\):
If \(\mathsf{pauliType} = Z\): Both faults pass the filter. The count is 2, which is even.
If \(\mathsf{pauliType} = Y\): Both faults pass the filter. The count is 2, which is even.
If \(\mathsf{pauliType} = X\): Neither fault passes the filter. The count is 0, which is even.
In all cases, the count is even.
For any time generator \(\mathsf{tg}\):
where \(\mathrm{identity}\) is the stabilizer check with empty \(X\)-support and empty \(Z\)-support.
The check \(\mathrm{spaceFaultsToCheck}(F)\) has \(X\)-support consisting of qubits \(q\) where the count of \(X\) or \(Y\) faults at \(q\) is odd, and similarly for \(Z\)-support. By Theorem 1552, for every qubit \(q\), the \(X\)/\(Y\) count is even (not odd), so the \(X\)-support is empty. By Theorem 1553, the \(Z\)/\(Y\) count is even for every \(q\), so the \(Z\)-support is empty. Therefore the result equals the identity check.
For any stabilizer code \(C\) and time generator \(\mathsf{tg}\):
1.13.6 Syndrome Cancellation for Time Generators
When measurement faults are placed on exactly the anticommuting checks, the syndrome is cancelled.
A Pauli fault \(P\) at qubit \(q\) affects the measurement of check \(j\) if and only if \(P\) anticommutes with check \(j\):
The syndrome of fault \(P\) on check \(C\) is 1 iff \([P, C] \neq 0\).
The syndrome contribution from a single Pauli fault on a check:
For any stabilizer code \(C\), time generator \(\mathsf{tg}\), and check index \(j\), the paired Pauli syndromes cancel:
where \(\mathrm{syndrome}_t = \mathrm{pauliSyndromeOnCheck}(C, \mathsf{tg}.\mathsf{pauliType}, \mathsf{tg}.\mathsf{qubit}, j)\).
The Pauli fault \(P\) at time \(t\) creates syndrome \(s\) on check \(j\). The same Pauli at time \(t+1\) creates the same syndrome \(s\). For a comparison detector: \(s \oplus s = 0\) in \(\mathbb {Z}/2\mathbb {Z}\). Concretely: if \(\mathrm{pauliFaultAffectsCheck}\) is true, then \(1 + 1 = 0\); if false, then \(0 + 0 = 0\). In both cases, the sum is 0.
1.13.7 Boundary Generators
At the boundary times \(t_i\) and \(t_o\), special generators arise from the initialization and readout of edge qubits.
An init-X boundary generator at time \(t_i\) models an initialization fault that prepares \(|1\rangle \) instead of \(|0\rangle \), paired with an \(X\) fault that converts it back. It consists of:
An edge qubit being initialized
The initialization time \(t_i\)
Since \(X|0\rangle = |1\rangle \), we have: (init to \(|1\rangle \)) \(=\) (init to \(|0\rangle \)) \(\circ \) \(X\). Therefore: (init fault) \(+\) (\(X\) fault) \(=\) no net effect.
The space faults of an init-X boundary generator consist of a single \(X\) fault at the edge qubit and initialization time:
An init-X boundary generator converts to a spacetime fault with the computed space faults and empty time faults.
The init-X boundary generator produces exactly one space fault:
The set \(\{ (X, \mathsf{edgeQubit}, \mathsf{initTime})\} \) is a singleton, which has cardinality 1.
An edge-measurement boundary generator at time \(t_i\) consists of a \(Z_e\) fault at \(t+1\) paired with \(A_v\) measurement faults for \(v \in e\) at \(t + 1/2\). It includes:
An edge qubit
The initialization time \(t_i\)
The vertex indices \(v \in e\) (the two endpoints of the edge)
A constraint: exactly 2 vertices per edge
The space faults consist of a \(Z\) fault at time \(t_i + 1\):
The time faults consist of \(A_v\) measurement faults at the vertex indices:
An edge-measurement boundary generator converts to a spacetime fault with the computed space faults and time faults.
The time faults of an edge-measurement boundary generator have exactly 2 elements (for the two vertices of the edge):
The time faults are the image of \(\mathsf{vertexIndices}\) under the map \(v \mapsto (v, \mathsf{initTime})\). This map is injective: if \((v_1, \mathsf{initTime}) = (v_2, \mathsf{initTime})\), then \(v_1 = v_2\). Since \(|\mathsf{vertexIndices}| = 2\) (by the constraint), the image also has cardinality 2.
A readout boundary generator at time \(t_o\) consists of an \(X_e\) fault at \(t\) paired with a \(Z_e\) measurement fault at \(t + 1/2\). It includes:
The edge qubit being read out
The readout time \(t_o\)
The measurement index for the \(Z_e\) measurement
The space faults consist of an \(X\) fault at the readout time:
The time faults consist of a measurement fault on the \(Z_e\) readout:
A readout boundary generator converts to a spacetime fault with the computed space faults and time faults.
The \(X\) fault and measurement fault cancel each other’s effect:
An \(X\) fault at time \(t\) flips the \(Z_e\) measurement at \(t + 1/2\). The measurement fault also flips the reported outcome. Two flips result in no net change.
By computation in \(\mathbb {Z}/2\mathbb {Z}\): \(1 + 1 = 0\).
1.13.8 Stabilizer Generator Classification
A spacetime stabilizer generator is one of the following types:
Space generator: A space generator \(\mathsf{sg}\) with proof that \(\mathrm{spaceFaultsToCheck}(\mathsf{sg}.\mathrm{toSpaceFaults})\) is a stabilizer element.
Time generator: A time generator (paired Paulis with measurement faults on anticommuting checks).
Init-X boundary generator: At \(t = t_i\), init fault paired with \(X\) fault.
Edge-measurement boundary generator: At \(t = t_i\), \(Z_e\) fault paired with \(A_v\) measurement faults.
Readout boundary generator: At \(t = t_o\), \(X_e\) fault paired with measurement fault.
1.13.9 Generator Properties
For any space generator \(\mathsf{sg}\), the time faults cancel (trivially, since there are no time faults):
Let \(\mathsf{idx}\) be any measurement index. The time faults of a space generator’s spacetime fault are empty (\(\emptyset \)). Filtering an empty set yields an empty set, which has cardinality 0. Since \(0 = 2 \cdot 0\), the count is even.
For any init-X boundary generator \(\mathsf{gen}\), the time faults cancel (trivially, since there are no time faults):
The time faults of an init-X boundary generator’s spacetime fault are empty (\(\emptyset \)). Filtering an empty set yields an empty set with cardinality 0, which is even.
1.13.10 Main Theorems
A spacetime fault \(F\) has a generator decomposition for code \(C\) if:
Time faults can be decomposed into generator contributions: \(\mathrm{timeFaultsCancel}(F.\mathrm{timeFaults})\)
Space faults form a stabilizer element: \(\mathrm{isStabilizerElement}(C, \mathrm{spaceFaultsToCheck}(F.\mathrm{spaceFaults}))\)
Every spacetime stabilizer has a generator decomposition. For any code \(C\), fault \(F\), and detector set \(D\):
Assume \(\mathrm{IsSpacetimeStabilizer}(C, F, D)\). The definition requires:
\(\mathrm{timeFaultsCancel}(F.\mathrm{timeFaults})\): This is exactly the time decomposability condition.
\(\mathrm{spaceFaultsAreStabilizer}(C, F.\mathrm{spaceFaults})\): This is exactly the space stabilizer condition.
Therefore \(F\) has a generator decomposition.
A fault with generator decomposition is a spacetime stabilizer on any detector set for which it is undetectable:
Assume \(\mathrm{HasGeneratorDecomposition}(C, F)\) and \(\mathrm{isUndetectable}(F, D)\). We construct the spacetime stabilizer structure:
Undetectable: Given by assumption \(\mathrm{isUndetectable}(F, D)\).
Time faults cancel: Given by \(\mathrm{HasGeneratorDecomposition}(C, F).\mathrm{time\_ decomposable}\).
Space faults are stabilizer: The condition \(\mathrm{spaceFaultsAreStabilizer}\) is defined as \(\mathrm{isStabilizerElement}(C, \mathrm{spaceFaultsToCheck}(F.\mathrm{spaceFaults}))\), which is given by \(\mathrm{HasGeneratorDecomposition}(C, F).\mathrm{space\_ in\_ stabilizer}\).
Therefore \(\mathrm{IsSpacetimeStabilizer}(C, F, D)\) holds.
A spacetime fault is a stabilizer if and only if it has a generator decomposition and is undetectable:
Forward direction (\(\Rightarrow \)): Assume \(\mathrm{IsSpacetimeStabilizer}(C, F, D)\). By Theorem 1577, \(F\) has a generator decomposition. By definition of spacetime stabilizer, \(F\) is undetectable.
Backward direction (\(\Leftarrow \)): Assume \(\mathrm{HasGeneratorDecomposition}(C, F)\) and \(\mathrm{isUndetectable}(F, D)\). By Theorem 1578, \(\mathrm{IsSpacetimeStabilizer}(C, F, D)\) holds.
1.13.11 Generator Type Classification
Generator types are classified as:
Space types:
\(\mathrm{spaceOriginalCheck}(j, t)\): Original check \(s_j\) at time \(t\) (for \(t {\lt} t_i\) or \(t {\gt} t_o\))
\(\mathrm{spaceDeformedCheck}(j, t)\): Deformed check \(\tilde{s}_j\) at time \(t\) (for \(t_i {\lt} t {\lt} t_o\))
\(\mathrm{spaceGaussLaw}(v, t)\): Gauss law \(A_v\) at time \(t\) (for \(t_i {\lt} t {\lt} t_o\))
\(\mathrm{spaceFlux}(p, t)\): Flux \(B_p\) at time \(t\) (for \(t_i {\lt} t {\lt} t_o\))
\(\mathrm{boundaryInitEdgeZ}(e)\): \(Z_e\) at time \(t_i\)
\(\mathrm{boundaryFinalEdgeZ}(e)\): \(Z_e\) at time \(t_o\)
Time types:
\(\mathrm{timePairX}(q, t)\): \(X\) pair on qubit \(q\) with anticommuting measurement faults
\(\mathrm{timePairZ}(q, t)\): \(Z\) pair on qubit \(q\) with anticommuting measurement faults
Boundary types:
\(\mathrm{boundaryInitXPair}(e)\): Initialization fault \(+\) \(X_e\) fault at \(t = t_i\)
\(\mathrm{boundaryEdgeMeas}(e)\): \(Z_e\) fault \(+\) \(A_v\) measurement faults at \(t = t_i\)
\(\mathrm{boundaryReadoutXPair}(e)\): \(X_e\) \(+\) \(Z_e\) measurement fault at \(t = t_o\)
A generator type is a space type if it is one of: \(\mathrm{spaceOriginalCheck}\), \(\mathrm{spaceDeformedCheck}\), \(\mathrm{spaceGaussLaw}\), \(\mathrm{spaceFlux}\), \(\mathrm{boundaryInitEdgeZ}\), or \(\mathrm{boundaryFinalEdgeZ}\).
A generator type is a time type if it is one of: \(\mathrm{timePairX}\) or \(\mathrm{timePairZ}\).
A generator type is a boundary type if it is one of: \(\mathrm{boundaryInitXPair}\), \(\mathrm{boundaryEdgeMeas}\), or \(\mathrm{boundaryReadoutXPair}\).
Every generator type is a space, time, or boundary type:
We proceed by case analysis on the generator type \(\mathsf{gt}\):
\(\mathrm{spaceOriginalCheck}\), \(\mathrm{spaceDeformedCheck}\), \(\mathrm{spaceGaussLaw}\), \(\mathrm{spaceFlux}\), \(\mathrm{boundaryInitEdgeZ}\), \(\mathrm{boundaryFinalEdgeZ}\): These satisfy \(\mathrm{isSpaceType} = \mathrm{true}\).
\(\mathrm{timePairX}\), \(\mathrm{timePairZ}\): These satisfy \(\mathrm{isTimeType} = \mathrm{true}\).
\(\mathrm{boundaryInitXPair}\), \(\mathrm{boundaryEdgeMeas}\), \(\mathrm{boundaryReadoutXPair}\): These satisfy \(\mathrm{isBoundaryType} = \mathrm{true}\).
All cases are covered by direct simplification.
1.14 Spacetime Fault Distance
The spacetime fault-distance of the fault-tolerant gauging measurement procedure is defined as
where \(|F|\) counts single-qubit Pauli errors plus single measurement errors.
Equivalently, \(d_{\text{ST}}\) is the minimum weight of an undetectable fault pattern that is not equivalent to a spacetime stabilizer.
1.14.1 Set of Logical Fault Weights
The set of weights of spacetime logical faults is defined as
An alternative characterization: the set of weights of undetectable faults that are not stabilizers, given by
The two weight sets are equal:
By extensionality, it suffices to show that \(w\) belongs to one set if and only if it belongs to the other. For the forward direction, assume \(w \in \text{logicalFaultWeights}\). Then there exists \(F\) with \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\) (which unfolds to \(\text{isUndetectable}(F, \text{detectors}) \land \neg \text{actsTriviallyOnMeasurement}(C, F)\)) and \(|F| = w\). This directly gives \(w \in \text{undetectableNonStabilizerWeights}\). For the backward direction, assume \(w \in \text{undetectableNonStabilizerWeights}\). Then there exists \(F\) with \(\text{isUndetectable}(F, \text{detectors})\), \(\neg \text{actsTriviallyOnMeasurement}(C, F)\), and \(|F| = w\). Packaging these together gives \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\), so \(w \in \text{logicalFaultWeights}\).
1.14.2 Spacetime Fault Distance Definition
A stabilizer code \(C\) with detector set has a logical fault if there exists at least one spacetime logical fault:
The spacetime fault-distance \(d_{\text{ST}}\) is defined as:
using the well-founded minimum on natural numbers. If no logical faults exist (which would mean perfect error correction), we return \(0\) as a sentinel value. In practice, interesting codes always have logical faults, so \(d_{\text{ST}} {\gt} 0\).
1.14.3 Main Properties
The spacetime fault distance is at most the weight of any logical fault:
Unfolding the definition of spacetime fault distance, we have that logical faults exist (since \(F\) is a witness). By the definition using conditional branching, we are in the case where we take the well-founded minimum. We apply the property that the minimum is a lower bound for all elements in the set, and \(|F| \in \text{logicalFaultWeights}\) by construction.
The spacetime fault distance is a lower bound: all logical faults have weight at least \(d_{\text{ST}}\):
This follows directly from Theorem 1590.
If logical faults exist, the minimum is achieved:
Unfolding the definition of spacetime fault distance with the assumption that logical faults exist, we are in the case where \(d_{\text{ST}}\) is the well-founded minimum. The set of logical fault weights is nonempty (since logical faults exist, we can take the weight of any such fault). By the property of well-founded minimum, there exists an element achieving the minimum. Decomposing this element, we obtain \(F\) with \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\) and \(|F| = d_{\text{ST}}\).
If no logical faults exist, then \(d_{\text{ST}} = 0\):
Unfolding the definition of spacetime fault distance, we use simplification with the assumption that no logical faults exist. By the conditional branching, this is the case where we return \(0\).
1.14.4 Properties of Spacetime Fault Distance
A fault with weight less than \(d_{\text{ST}}\) cannot be a logical fault:
Assume for contradiction that \(F\) is a logical fault. By Theorem 1590, we have \(d_{\text{ST}} \leq |F|\). But we assumed \(|F| {\lt} d_{\text{ST}}\), which by linear arithmetic gives a contradiction.
A fault with weight less than \(d_{\text{ST}}\) is either detectable or a stabilizer:
By contraposition, assume both that \(F\) is undetectable and that \(F\) is not a stabilizer. Then \(F\) is a logical fault by definition. But by Theorem 1594, this contradicts \(|F| {\lt} d_{\text{ST}}\).
1.14.5 Spacetime Fault Distance Structure
A structure bundling the spacetime fault distance with a witness achieving the minimum. It contains:
witness: The minimum weight logical fault \(F\)
isLogical: Proof that the witness is a logical fault
achievesMin: Proof that \(|F| = d_{\text{ST}}\)
The distance value associated with a witness is simply \(d_{\text{ST}}\).
For a witness \(w\), the distance equals the witness weight:
This follows by symmetry from the achievesMin field of the witness structure.
The witness of a spacetime fault distance witness is undetectable:
This follows from the first component of the isLogical field.
The witness of a spacetime fault distance witness is not a stabilizer:
This follows from the second component of the isLogical field.
Constructs a witness from the existence of logical faults using the axiom of choice.
1.14.6 Fault-Tolerance Threshold
A code can tolerate faults of weight \(t\) if \(t {\lt} d_{\text{ST}}\). This section establishes the relationship between fault tolerance and \(d_{\text{ST}}\).
A code can tolerate weight-\(t\) faults if \(t {\lt} d_{\text{ST}}\):
If the code can tolerate weight \(t\), any fault of weight at most \(t\) is either detectable or a stabilizer:
We have \(|F| \leq t {\lt} d_{\text{ST}}\) by the tolerance assumption and the weight bound. By linear arithmetic, \(|F| {\lt} d_{\text{ST}}\). The result then follows from Theorem 1595.
The maximum tolerable fault weight is \(d_{\text{ST}} - 1\) when \(d_{\text{ST}} {\gt} 0\):
Unfolding the definition of canTolerateFaults, we need to show \(d_{\text{ST}} - 1 {\lt} d_{\text{ST}}\). This follows by linear arithmetic from the assumption \(0 {\lt} d_{\text{ST}}\).
1.14.7 Helper Lemmas
The spacetime fault distance is non-negative:
This follows from the fact that \(d_{\text{ST}} \in \mathbb {N}\).
Logical fault weights are bounded below by \(d_{\text{ST}}\):
Let \(w \in \text{logicalFaultWeights}\). By definition, there exists \(F\) with \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\) and \(|F| = w\). Rewriting with \(|F| = w\), the result follows from Theorem 1590.
If logical faults exist, the weight set is nonempty:
From the existence of logical faults, we obtain \(F\) with \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\). Then \(|F| \in \text{logicalFaultWeights}\) by construction.
\(d_{\text{ST}} \in \text{logicalFaultWeights}\) when logical faults exist:
By Theorem 1592, there exists \(F\) with \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\) and \(|F| = d_{\text{ST}}\). Thus \(d_{\text{ST}} \in \text{logicalFaultWeights}\) by definition.
A fault of weight exactly \(d_{\text{ST}}\) exists when logical faults exist:
This is exactly Theorem 1592.
1.14.8 Distance Positivity Characterization
\(d_{\text{ST}} {\gt} 0\) if and only if logical faults exist and all have positive weight:
For the forward direction, assume \(0 {\lt} d_{\text{ST}}\). By contraposition of Theorem 1593, logical faults must exist (otherwise \(d_{\text{ST}} = 0\)). For any logical fault \(F\), by Theorem 1590, \(d_{\text{ST}} \leq |F|\), so \(0 {\lt} |F|\) by linear arithmetic.
For the backward direction, assume logical faults exist and all have positive weight. By Theorem 1592, there exists \(F\) with \(|F| = d_{\text{ST}}\). By assumption, \(0 {\lt} |F|\). Rewriting gives \(0 {\lt} d_{\text{ST}}\).
1.14.9 Equivalent Characterization
The spacetime fault distance is equivalently:
By Theorem 1592, there exists \(F\) with \(\text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors})\) and \(|F| = d_{\text{ST}}\). Unfolding the definition, \(F\) is undetectable and not a stabilizer, which gives the desired characterization.
1.14.10 Basic Facts About Distance
The distance is well-defined: if logical faults exist, \(d_{\text{ST}}\) is their minimum. Specifically:
\(\forall F, \; \text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors}) \Rightarrow d_{\text{ST}} \leq |F|\)
\(\exists F, \; \text{IsSpacetimeLogicalFaultConcrete}(C, F, \text{detectors}) \land |F| = d_{\text{ST}}\)
1.14.11 Relationship to Stabilizer Code
The distance depends on the stabilizer structure. For any logical fault \(F\):
From the logical fault hypothesis, we have \(\neg \text{actsTriviallyOnMeasurement}(C, F)\). Unfolding this definition and pushing negation inward, we get that at least one of the two conditions for trivial action fails. This is exactly the disjunction we want.
The empty fault is not a logical fault (it is a stabilizer):
Assume for contradiction that the empty fault is a logical fault. By Theorem 1497, the empty fault acts trivially on measurement (is a stabilizer). But a logical fault must not act trivially, giving a contradiction.
If \(d_{\text{ST}} {\gt} 0\), weight-0 undetectable faults must be stabilizers. This shows that \(d_{\text{ST}}\) is a meaningful measure of code quality:
Let \(F\) be a fault with \(|F| = 0\) that is undetectable. Assume for contradiction that \(F\) does not act trivially on measurement. Then \(F\) is a logical fault. By Theorem 1590, \(d_{\text{ST}} \leq |F| = 0\). But \(0 {\lt} d_{\text{ST}}\), which by linear arithmetic gives a contradiction.
1.15 Time Fault Distance (Lemma 5)
The fault-distance for pure measurement and initialization errors is \((t_o - t_i)\), the number of rounds between the start and end of code deformation. Specifically: Any spacetime logical fault consisting only of measurement/initialization errors has weight \(\geq t_o - t_i\).
1.15.1 Pure Time Fault Predicate
A spacetime fault \(F\) is a pure time fault if it has no space faults:
If \(F\) is a pure time fault, then its weight equals the cardinality of its time faults:
Unfolding the definitions of weight and pure time fault, and using the fact that the space faults are empty, we simplify to obtain the result.
The empty spacetime fault is a pure time fault.
This holds by reflexivity of the definition: the empty fault has empty space faults.
For a pure time fault \(F\):
Rewriting with the pure time fault weight theorem, the result follows from the fact that a finset has cardinality zero if and only if it is empty.
1.15.2 Code Deformation Interval
A code deformation interval consists of:
\(t_i\) : the initial time step
\(t_o\) : the final time step
A proof that \(t_i \leq t_o\)
The number of rounds in an interval \(I\) is:
For any code deformation interval \(I\), \(0 \leq \mathrm{numRounds}(I)\).
This follows from the fact that natural number subtraction is always nonnegative.
If \(t_i = t_o\), then \(\mathrm{numRounds}(I) = 0\).
Unfolding the definition of numRounds and rewriting with \(t_i = t_o\), we get \(t_o - t_o = 0\).
If \(t_i {\lt} t_o\), then \(0 {\lt} \mathrm{numRounds}(I)\).
This follows from the fact that \(a - b {\gt} 0\) when \(b {\lt} a\) for natural numbers.
The trivial interval at time \(t\) has \(t_i = t_o = t\).
For any time step \(t\), \(\mathrm{numRounds}(\mathrm{trivial}(t)) = 0\).
This follows from \(t - t = 0\).
The interval starting at \(t_{\mathrm{start}}\) with given duration has \(t_i = t_{\mathrm{start}}\) and \(t_o = t_{\mathrm{start}} + \mathrm{duration}\).
\(\mathrm{numRounds}(\mathrm{ofDuration}(t_{\mathrm{start}}, d)) = d\).
By simplification using the definitions of ofDuration and numRounds.
1.15.3 Time Fault Coverage
The set of rounds covered by time faults is the image of the measurement round function:
Time faults cover all rounds in interval \(I\) if:
1.15.4 Comparison Detector Model
A comparison detector consists of a measurement index and a round number. It compares the measurement outcome at round \(t\) with that at round \(t-1\).
The count of time faults at a given index and round:
A set of faults violates a comparison detector \(D\) if the parity of faults at round \(D.\mathrm{round}\) differs from the parity at round \(D.\mathrm{round} - 1\):
where the count at round 0 is treated as 0 when comparing.
An interior comparison detector only fires when both \(t\) and \(t-1\) are in the interval \([t_i, t_o)\). This models the fact that faults can “enter” at \(t_i\) and “exit” at \(t_o\) without detection:
1.15.5 Key Lemmas - Parity Propagation
If a comparison detector at round \(t {\gt} 0\) doesn’t fire, the parities at rounds \(t\) and \(t-1\) match:
Unfolding the definition of violatesComparisonDetector and simplifying with the negation, we obtain the equality of parities. Since \(t \neq 0\), the conditional for the previous round count is resolved, yielding the equivalence.
If the fault count at some index and round is positive, that round is covered:
Unfolding timeFaultCountAt, we use the positive cardinality to extract a fault \(f\) from the filtered set. This fault is in the original set, and its measurement round equals \(t\), so \(t\) is in the image.
1.15.6 Chain Coverage Theorem
All rounds in an interval have the same parity if no comparison detector fires. For \(t_1, t_2 \in [t_i, t_o)\):
We proceed by symmetry, assuming \(t_1 \leq t_2\) without loss of generality. We then proceed by induction on the difference \(t_2 - t_1\).
Base case (\(d = 0\)): When \(t_1 = t_2\), the result is trivial by reflexivity.
Inductive step: Suppose \(t_2 = t_1 + d + 1\). By the inductive hypothesis, \(\mathrm{Odd}(\mathrm{count}_{t_1}) \iff \mathrm{Odd}(\mathrm{count}_{t_1+d})\). By the no-violation hypothesis at round \(t_1 + d + 1\), we have that the parity at \(t_1 + d + 1\) equals the parity at \(t_1 + d\).Combining these gives the result.
If an index has a fault with odd count at some round in the interval, then all rounds have positive (hence odd) count:
Let \(t \in [t_i, t_o)\) be arbitrary. By the same parity in interval theorem, \(\mathrm{Odd}(\mathrm{count}_{t_0}) \iff \mathrm{Odd}(\mathrm{count}_t)\). Since the count at \(t_0\) is odd, the count at \(t\) is also odd. An odd number \(2k+1\) is positive, so \(\mathrm{count}_t {\gt} 0\).
If no comparison detector fires and there exists an odd-count fault in the interval, then all rounds are covered:
From the existence hypothesis, we obtain an index \(\mathrm{idx}\) and round \(t_0 \in [t_i, t_o)\) with odd count. For any \(t \in [t_i, t_o)\), we apply chain_coverage_at_index to conclude \(\mathrm{count}_t {\gt} 0\), then apply fault_at_implies_covered to conclude \(t\) is covered.
1.15.7 Round Coverage Implies Weight Bound
If time faults cover all rounds in an interval, then the number of covered rounds is at least the number of rounds:
If \(t_o \leq t_i\), then \(\mathrm{numRounds} = 0\) and the result is trivial. Otherwise, consider the set \([t_i, t_o)\) as a finset. By the coverage hypothesis, this set is a subset of coveredRounds. The cardinality of \([t_i, t_o)\) is \(t_o - t_i = \mathrm{numRounds}\), and the cardinality of a subset is at most that of the superset.
The cardinality of covered rounds is at most the cardinality of time faults:
This follows from the fact that the image of a finset under any function has cardinality at most that of the original finset.
If time faults cover all rounds in an interval, the cardinality of time faults is at least the number of rounds:
By transitivity: \(\mathrm{numRounds} \leq |\mathrm{coveredRounds}| \leq |\mathrm{timeFaults}|\).
1.15.8 Pure Time Fault Action Conditions
For a pure time fault \(F\), acting trivially on measurement is equivalent to time faults canceling:
For the forward direction, we extract the time faults cancel condition from the definition of acts trivially. For the backward direction, we verify both conditions: time faults cancel is given, and space faults are stabilizer holds because the space faults are empty, so spaceFaultsToCheck is the identity, which is a stabilizer.
For a pure time fault \(F\):
Unfolding the definition of IsSpacetimeLogicalFaultConcrete and rewriting with the pure time fault acts trivially equivalence.
1.15.9 Main Theorem
Main Theorem (Lemma 5): For a pure time fault \(F\), if comparison detectors don’t fire and there’s an odd-count fault in the interval:
We first apply undetectable_covers_rounds to conclude that all rounds are covered. Then we rewrite the weight using the pure time fault weight theorem. Finally, we apply time_faults_cover_implies_weight_bound.
1.15.10 Achievability - Chain Faults Are Logical Faults
A time fault chain for interval \(I\) at index \(\mathrm{idx}\) contains one fault at each round in \([t_i, t_o)\):
The cardinality of a time fault chain equals the number of rounds:
Unfolding the definitions, we compute the cardinality of the image. The mapping \(t \mapsto \langle \mathrm{idx}, t\rangle \) is injective (if two time faults are equal, their rounds are equal). The cardinality of \([t_i, t_o)\) is \(t_o - t_i = \mathrm{numRounds}\).
A time fault chain covers all rounds in its interval.
Let \(t \in [t_i, t_o)\). We need to show \(t \in \mathrm{coveredRounds}(\mathrm{chain})\). The fault \(\langle \mathrm{idx}, t\rangle \) is in the chain (by definition of the image), and its measurement round is \(t\).
A spacetime fault constructed from a time fault chain with empty space faults.
A fault constructed from a chain is a pure time fault.
This holds by reflexivity: the construction sets spaceFaults to empty.
The weight of a chain fault equals the number of rounds:
By simplification: the weight is \(|\emptyset | + |\mathrm{chain}| = 0 + I.\mathrm{numRounds}\).
The count at the chain index for \(t \in [t_i, t_o)\) is exactly 1:
Unfolding the definitions, we show the filtered set contains exactly the fault \(\langle \mathrm{idx}, t\rangle \). Any fault in the chain with matching index and round must be this fault. Conversely, this fault satisfies all conditions.
The count at the chain index for \(t \notin [t_i, t_o)\) is 0:
Unfolding the definitions, we show the filtered set is empty. Any fault in the chain has round \(t'\) with \(t_i \leq t' {\lt} t_o\). If the fault has round equal to \(t\), we get a contradiction with the hypothesis \(t {\lt} t_i\) or \(t_o \leq t\).
The count at a different index is always 0:
Unfolding the definitions, we show the filtered set is empty. Any fault in the chain has index \(\mathrm{idx}\). If a fault has index \(\mathrm{idx}'\), we contradict \(\mathrm{idx} \neq \mathrm{idx}'\).
A chain fault doesn’t violate interior comparison detectors at its index. This models the boundary condition: faults can “enter” at \(t_i\) and “exit” at \(t_o\) without detection.
Let \(t\) satisfy \(t_i {\lt} t {\lt} t_o\). Then \(t_i \leq t - 1 {\lt} t_o\) as well, so both counts are 1. Since \(\mathrm{Odd}(1) = \mathrm{Odd}(1)\), no violation occurs.
A chain fault doesn’t violate interior comparison detectors at other indices (count = 0 everywhere).
At any index \(\mathrm{idx}' \neq \mathrm{idx}\), the count is 0 at all rounds. Since \(\mathrm{Odd}(0) = \mathrm{Odd}(0)\), no violation occurs.
When the number of rounds is odd, the chain fault does not cancel:
Suppose for contradiction that the faults cancel. Then the count of faults at index \(\mathrm{idx}\) is even. But all faults in the chain have index \(\mathrm{idx}\), so this count equals \(|\mathrm{chain}| = I.\mathrm{numRounds}\). This contradicts the hypothesis that numRounds is odd.
If a chain fault doesn’t violate any detector in a set, it is undetectable with respect to that set.
Unfolding isUndetectable and syndromeFinset, a detector is in the syndrome iff it is in the set and is violated. By hypothesis, no detector is violated.
Achievability Theorem: When the number of rounds is odd and no detector is violated, the chain fault is a logical fault:
We verify both conditions:
Undetectable: By chainFault_undetectable_for_detectors, the chain is undetectable.
Not trivial action: Rewriting with isPureTimeFault_actsTrivially_iff (using pureTimeFaultFromChain_isPure), it suffices to show the time faults don’t cancel. This follows from chainFault_not_cancel with the odd numRounds hypothesis.
1.15.11 Summary Theorem
For a stabilizer code \(C\) and interval \(I\) with \(m {\gt} 0\):
Lower bound: Any pure time fault \(F\) with no comparison detector violations and an odd-count fault in the interval satisfies \(I.\mathrm{numRounds} \leq F.\mathrm{weight}\).
Achievable upper bound: For any index, \((\mathrm{pureTimeFaultFromChain}).\mathrm{weight} = I.\mathrm{numRounds}\).
Chain is logical: When numRounds is odd and no detector is violated, the chain is a logical fault.
We verify each part:
By pure_time_fault_weight_ge_rounds.
By pureTimeFaultFromChain_weight.
By chain_is_logical_fault.
1.16 Spacetime Fault Decoupling (Lemma 6)
This section establishes that any spacetime logical fault can be decomposed into the product of a space logical fault and a time logical fault, up to multiplication with spacetime stabilizers.
1.16.1 Space-Only Fault
A space-only fault is a spacetime fault where all space errors occur at a single time slice. This represents “instantaneous” Pauli errors. Formally, it consists of:
An underlying spacetime fault \(F\)
A time slice \(t\) at which all space faults occur
The property that all space faults in \(F\) have time step equal to \(t\)
No time faults: \(F.\mathrm{timeFaults} = \emptyset \)
The weight of a space-only fault \(F\) is defined as the weight of the underlying spacetime fault.
For a space-only fault \(F\), we have \(\mathrm{weight}(F) = |F.\mathrm{fault}.\mathrm{spaceFaults}|\).
By unfolding the definitions of weight and spacetime fault weight, and using the property that \(F\) has no time faults, the result follows by simplification.
The empty space-only fault at time \(t\) is constructed from the empty spacetime fault with time slice \(t\).
For any time step \(t\), the empty space-only fault at \(t\) has weight \(0\).
By simplification using the definitions of empty, weight, spacetime fault weight, and empty spacetime fault.
A space-only fault \(F\) satisfies \(F.\mathrm{fault}.\mathrm{timeFaults} = \emptyset \).
This follows directly from the no_time_faults field of the space-only fault structure.
1.16.2 Time-Only Fault (Pure Time Fault)
A time-only fault is a spacetime fault with no space component. This represents only measurement/initialization errors. It consists of:
An underlying spacetime fault \(F\)
The property that \(F.\mathrm{spaceFaults} = \emptyset \)
The weight of a time-only fault \(F\) is defined as the weight of the underlying spacetime fault.
For a time-only fault \(F\), we have \(\mathrm{weight}(F) = |F.\mathrm{fault}.\mathrm{timeFaults}|\).
By unfolding the definitions of weight and spacetime fault weight, and using the property that \(F\) has no space faults, the result follows by simplification.
The empty time-only fault is constructed from the empty spacetime fault.
The empty time-only fault has weight \(0\).
By simplification using the definitions of empty, weight, spacetime fault weight, and empty spacetime fault.
A time-only fault \(F\) is a pure time fault.
This follows directly from the no_space_faults field of the time-only fault structure.
Construct a time-only fault from a set of time faults by taking empty space faults and the given time faults.
For a finite set of time faults \(S\), the weight of \(\mathrm{ofTimeFaults}(S)\) equals \(|S|\).
By simplification using the definitions.
1.16.3 Fault Product
The product of two spacetime faults \(F_1\) and \(F_2\) is defined as their union. This models the composition of independent fault events.
For spacetime faults \(F_1\) and \(F_2\), we have \(F_1 \cdot F_2 = F_2 \cdot F_1\).
By the definition of product as union, this follows from the commutativity of finite set union.
For spacetime faults \(F_1\), \(F_2\), and \(F_3\), we have \((F_1 \cdot F_2) \cdot F_3 = F_1 \cdot (F_2 \cdot F_3)\).
By the definition of product as union, this follows from the associativity of finite set union.
For any spacetime fault \(F\), we have \(\emptyset \cdot F = F\).
By the definitions of product, union, and empty fault, this follows from the property that the empty set is a left identity for union.
For any spacetime fault \(F\), we have \(F \cdot \emptyset = F\).
By the definitions of product, union, and empty fault, this follows from the property that the empty set is a right identity for union.
1.16.4 Time Translation Stabilizers
The key insight is that a Pauli error at time \(t\) can be “moved” to time \(t'\) by introducing the same Pauli at both times. The pair \((\text{Pauli}_t, \text{Pauli}_{t'})\) forms a spacetime stabilizer because \(P^2 = I\) for all Pauli operators.
The canonical time slice \(t_i\) is defined as \(0\).
The time translation fault for a space fault \(f\) and target time \(t_{\mathrm{target}}\) is defined as:
This represents the “cleaning” step: moving a fault from time \(t\) to time \(t'\).
For any space fault \(f\) and target time \(t_{\mathrm{target}}\), the time translation fault has no time faults.
This holds by reflexivity from the definition, which sets \(\mathrm{timeFaults} = \emptyset \).
If \(f.\mathrm{timeStep} \neq t_{\mathrm{target}}\), then \(f \in \mathrm{timeTranslationFault}(f, t_{\mathrm{target}}).\mathrm{spaceFaults}\).
By simplification: when \(f.\mathrm{timeStep} \neq t_{\mathrm{target}}\), the space faults are \(\{ f, \langle f.\mathrm{pauliType}, f.\mathrm{qubit}, t_{\mathrm{target}} \rangle \} \), and \(f\) is clearly in this set.
If \(f.\mathrm{timeStep} \neq t_{\mathrm{target}}\), then \(\langle f.\mathrm{pauliType}, f.\mathrm{qubit}, t_{\mathrm{target}} \rangle \in \mathrm{timeTranslationFault}(f, t_{\mathrm{target}}).\mathrm{spaceFaults}\).
By simplification: when \(f.\mathrm{timeStep} \neq t_{\mathrm{target}}\), the space faults are \(\{ f, \langle f.\mathrm{pauliType}, f.\mathrm{qubit}, t_{\mathrm{target}} \rangle \} \), and the projected fault is clearly in this set.
For any stabilizer code \(C\), space fault \(f\), and target time \(t_{\mathrm{target}}\), the time translation fault acts trivially on the code space:
The proof uses that a Pauli at time \(t\) paired with the same Pauli at time \(t'\) produces the identity on the code space (since \(P^2 = I\) for Pauli operators).
We unfold the definitions of \(\mathrm{spaceFaultsAreStabilizer}\), \(\mathrm{spaceFaultsToCheck}\), \(\mathrm{isStabilizerElement}\), and \(\mathrm{timeTranslationFault}\). We witness the empty set of checks and rewrite using \(\mathrm{productOfChecks\_ empty}\). We need to show that the supports (both X and Z) are empty.
We consider two cases based on whether \(f.\mathrm{timeStep} = t_{\mathrm{target}}\):
Case 1: If \(f.\mathrm{timeStep} = t_{\mathrm{target}}\), the translation set is empty, so both supports are trivially empty.
Case 2: If \(f.\mathrm{timeStep} \neq t_{\mathrm{target}}\), the translation set is \(\{ f, \langle f.\mathrm{pauliType}, f.\mathrm{qubit}, t_{\mathrm{target}} \rangle \} \).
For the X support, we show it is empty by extensionality. For each qubit \(q\):
If \(q \neq f.\mathrm{qubit}\): the count of faults at \(q\) with X or Y type is 0.
If \(q = f.\mathrm{qubit}\) and \(f\) has X or Y type: the count is exactly 2 (both faults), which is even, not odd.
If \(q = f.\mathrm{qubit}\) and \(f\) has Z type only: the count is 0.
In all cases, the parity is even, so \(q\) is not in the support.
The argument for the Z support is symmetric, considering Z or Y type instead.
1.16.5 Extraction Functions and Projection
Project a space fault to the canonical time slice by keeping its Pauli type and qubit but changing the time to \(t_i = 0\).
Project all space faults to a given time slice \(t\) by mapping each fault \(f\) to \(\langle f.\mathrm{pauliType}, f.\mathrm{qubit}, t \rangle \).
Extract the time-fault component from a spacetime fault, yielding a time-only fault with the same time faults and empty space faults.
For any spacetime fault \(F\), \((\mathrm{extractTimeFaults}(F)).\mathrm{fault}.\mathrm{timeFaults} = F.\mathrm{timeFaults}\).
This holds by reflexivity from the definition.
Create a space-only fault from a spacetime fault by projecting its space faults to a given time slice.
1.16.6 Decomposition Components
The stabilizer correction space faults for the decomposition. For each space fault \(f\) not at canonical time, includes both \(f\) and its projection to canonical time. This forms a stabilizer because each pair \((f, \mathrm{projected}_f)\) acts trivially (\(P^2 = I\)).
The stabilizer correction fault for decomposition, constructed from the decomposition stabilizer space faults with no time faults.
The space-only component of the decomposition, with all faults projected to canonical time.
The time-only component of the decomposition is exactly the extracted time faults.
1.16.7 Stabilizer Property of Individual Time Translations
For each fault at a non-canonical time, the time-translation stabilizer acts trivially.
This is a direct application of timeTranslationFault_acts_trivially.
1.16.8 Main Decomposition Theorem
Main Theorem: Any spacetime fault decomposes into space-only and time-only components, with a stabilizer correction relating them to the original.
For any stabilizer code \(C\), set of detectors, and spacetime fault \(F\), there exist:
A spacetime fault \(S\) (the stabilizer correction)
A space-only fault \(F_S\)
A time-only fault \(F_T\)
satisfying:
\(F_S\) has all space faults at canonical time: \(F_S.\mathrm{timeSlice} = t_i\)
\(F_T\) has exactly the original time faults: \(F_T.\mathrm{fault}.\mathrm{timeFaults} = F.\mathrm{timeFaults}\)
\(F_S.\mathrm{spaceFaults}\) is the projection of \(F.\mathrm{spaceFaults}\) to canonical time
\(S\) has no time faults: \(S.\mathrm{timeFaults} = \emptyset \)
Each time-translation pair in \(S\) is individually a stabilizer
The decomposition captures all original faults: every original space fault is either in \(F_S\) (if at canonical time) or paired in \(S\)
Detector consistency: if \(F\) is undetectable then its syndrome weight is 0
We construct the decomposition using \(S = \mathrm{decompositionStabilizer}(F)\), \(F_S = \mathrm{decompositionSpacePart}(F)\), and \(F_T = \mathrm{decompositionTimePart}(F)\).
Properties (1)–(4) follow immediately by reflexivity from the definitions.
For property (5), let \(f \in F.\mathrm{spaceFaults}\) with \(f.\mathrm{timeStep} \neq t_i\). By timeTranslationFault_acts_trivially, the time translation fault for \(f\) and \(t_i\) is a stabilizer.
For property (6), let \(f \in F.\mathrm{spaceFaults}\):
If \(f.\mathrm{timeStep} = t_i\): By the definition of \(\mathrm{decompositionSpacePart}\) and \(\mathrm{projectSpaceFaultsToSlice}\), we can witness \(f\) mapping to itself, so \(f \in F_S.\mathrm{fault}.\mathrm{spaceFaults}\).
If \(f.\mathrm{timeStep} \neq t_i\): By the definitions of \(\mathrm{decompositionStabilizer}\) and \(\mathrm{decompositionStabilizerSpaceFaults}\), both \(f\) and \(\mathrm{projectToCanonical}(f)\) are in \(S.\mathrm{spaceFaults}\).
For property (7), this follows from isUndetectable_iff_syndromeWeight_zero.
For any spacetime fault \(F\), \((\mathrm{decompositionTimePart}(F)).\mathrm{fault}.\mathrm{timeFaults} = F.\mathrm{timeFaults}\).
This holds by reflexivity from the definition.
For any spacetime fault \(F\), \((\mathrm{decompositionSpacePart}(F)).\mathrm{fault}.\mathrm{spaceFaults} = \mathrm{projectSpaceFaultsToSlice}(F.\mathrm{spaceFaults}, t_i)\).
This holds by reflexivity from the definition.
1.16.9 Properties
For faults already at canonical time, no stabilizer correction is needed. Specifically, for a space fault \(f\) with \(f.\mathrm{timeStep} = t_i\):
By case analysis on \(f = \langle p, q, t \rangle \). Since \(t = t_i\) by assumption, the two singletons are equal, so the equivalence holds by reflexivity.
1.16.10 Weight Bounds
The time component weight equals the original time fault count:
By unfolding the definitions and simplification.
The space component weight is at most the original space fault count:
By unfolding the definitions and applying the fact that the cardinality of an image is at most the cardinality of the original set.
1.16.11 Uniqueness
Two decompositions using the same canonical time have identical space and time components. Specifically, if \(S_1\) and \(S_2\) are space-only faults and \(T_1\) and \(T_2\) are time-only faults such that:
\(S_1.\mathrm{fault}.\mathrm{spaceFaults} = \mathrm{projectSpaceFaultsToSlice}(F.\mathrm{spaceFaults}, t_i)\)
\(S_2.\mathrm{fault}.\mathrm{spaceFaults} = \mathrm{projectSpaceFaultsToSlice}(F.\mathrm{spaceFaults}, t_i)\)
\(T_1.\mathrm{fault}.\mathrm{timeFaults} = F.\mathrm{timeFaults}\)
\(T_2.\mathrm{fault}.\mathrm{timeFaults} = F.\mathrm{timeFaults}\)
Then \(S_1.\mathrm{fault}.\mathrm{spaceFaults} = S_2.\mathrm{fault}.\mathrm{spaceFaults}\) and \(T_1.\mathrm{fault}.\mathrm{timeFaults} = T_2.\mathrm{fault}.\mathrm{timeFaults}\).
By transitivity of equality: \(S_1.\mathrm{spaceFaults} = \mathrm{proj}(F) = S_2.\mathrm{spaceFaults}\) and similarly for time faults.
1.16.12 Corollaries
For logical faults, at least one component is non-trivial. If \(F\) is a spacetime logical fault, then:
We proceed by contradiction. Suppose both weights are at most 0, hence equal to 0.
From the space component having weight 0, we deduce that the projection of \(F.\mathrm{spaceFaults}\) to canonical time is empty. This implies \(F.\mathrm{spaceFaults}\) itself is empty (otherwise, there would be at least one projected fault).
From the time component having weight 0, we deduce \(F.\mathrm{timeFaults} = \emptyset \).
Since both space and time faults are empty, the fault \(F\) acts trivially on measurement:
There are no time faults to flip parities
The space faults form the empty set, which maps to the identity check, which is a stabilizer
But this contradicts the assumption that \(F\) is a logical fault (which by definition does not act trivially).
Each space fault in the original has a corresponding projected fault:
By the definitions, the projected fault is the image of \(f\) under projection, so it is in the image set.
Time faults are preserved exactly: \((\mathrm{decompositionTimePart}(F)).\mathrm{fault}.\mathrm{timeFaults} = F.\mathrm{timeFaults}\).
This holds by reflexivity from the definition.
The weight of the decomposition is controlled:
The first inequality follows from space_component_weight_le and the equality follows from time_component_weight.
1.17 Fault Tolerance (Theorem 2)
This section establishes the main fault tolerance theorem: the fault-tolerant implementation of the gauging measurement procedure with a suitable graph \(G\) has spacetime fault-distance \(d\).
Specifically, if:
The gauging graph satisfies \(h(G) \geq 1\) (Cheeger constant at least 1)
The number of syndrome measurement rounds satisfies \(t_o - t_i \geq d\)
Then any undetectable fault pattern that affects the computation has weight at least \(d\).
1.17.1 Code Deformation Interval
The code deformation interval \([t_i, t_o]\) defines when gauging is active. The key condition is \(t_o - t_i \geq d\) for fault tolerance.
A fault tolerance parameter structure consists of:
\(n\): the number of physical qubits
\(k\): the number of encoded qubits
\(d\): the code distance
\(m\): the number of measurement types
A stabilizer code \(C\) on \(n\) qubits encoding \(k\) logical qubits
A set of detectors for syndrome extraction
A code deformation interval \([t_i, t_o]\)
No proof needed for definitions.
For fault tolerance parameters, the number of syndrome measurement rounds is defined as the number of rounds in the code deformation interval: \(\text{numRounds} := t_o - t_i\).
No proof needed for definitions.
The code distance of a fault tolerance parameter structure is simply the distance parameter \(d\).
No proof needed for definitions.
1.17.2 Time Distance Bound (from Lemma 5)
Pure time logical faults have weight \(\geq \) numRounds. Combined with numRounds \(\geq d\), this gives weight \(\geq d\).
Let \(F\) be a spacetime fault that is pure time (i.e., has no space faults). Suppose:
For all measurement indices \(\text{idx}\) and time steps \(t\) with \(t_i \leq t {\lt} t_o\), \(F\) does not violate the comparison detector at \((\text{idx}, t)\).
There exists a measurement index \(\text{idx}\) and time \(t_0\) with \(t_i \leq t_0 {\lt} t_o\) such that the time fault count at \((\text{idx}, t_0)\) is odd.
Then \(\text{weight}(F) \geq t_o - t_i\).
This is derived from the chain coverage property: undetectable pure time faults must have odd count at some index, and no comparison detector violations means same parity across all rounds, so faults must cover all rounds from \(t_i\) to \(t_o\).
This follows directly from pure_time_fault_weight_ge_rounds.
Under the same conditions as the Time Distance Bound, if additionally the number of rounds satisfies \(\text{numRounds} \geq d\), then \(\text{weight}(F) \geq d\).
We have \(\text{weight}(F) \geq \text{numRounds}\) by the Time Distance Bound. Since \(\text{numRounds} \geq d\), transitivity of \(\leq \) gives \(\text{weight}(F) \geq d\).
1.17.3 Space Distance Bound (from Lemma 2)
Space logical faults have weight \(\geq \min (h(G), 1) \cdot d\). When \(h(G) \geq 1\), this gives weight \(\geq d\).
A spacetime fault \(F\) is space-only if it has no time faults: \(F.\text{timeFaults} = \emptyset \).
No proof needed for definitions.
A spacetime fault \(F\) is time-only if it has no space faults: \(F.\text{spaceFaults} = \emptyset \).
No proof needed for definitions.
If \(F\) is a space-only fault, then \(\text{weight}(F) = |F.\text{spaceFaults}|\).
By definition of space-only, \(F.\text{timeFaults} = \emptyset \), so \(|F.\text{timeFaults}| = 0\). The weight is defined as \(|F.\text{spaceFaults}| + |F.\text{timeFaults}|\). By simplification, this equals \(|F.\text{spaceFaults}|\).
If \(F\) is a time-only fault, then \(\text{weight}(F) = |F.\text{timeFaults}|\).
By definition of time-only, \(F.\text{spaceFaults} = \emptyset \), so \(|F.\text{spaceFaults}| = 0\). The weight is defined as \(|F.\text{spaceFaults}| + |F.\text{timeFaults}|\). By simplification, this equals \(|F.\text{timeFaults}|\).
A simple graph \(G\) satisfies the Cheeger condition if its Cheeger constant is at least 1: \(h(G) \geq 1\).
No proof needed for definitions.
When \(h(G) \geq 1\), the Cheeger factor equals 1, so the bound \(d^* \geq \min (h(G), 1) \cdot d = d\).
This follows directly from cheegerFactor_eq_one_of_cheeger_ge_one.
When \(G\) satisfies the Cheeger condition (i.e., \(h(G) \geq 1\)), the Cheeger factor is exactly 1.
This follows directly from cheegerFactor_eq_one_of_cheeger_ge_one.
For a deformed logical operator \(L_{\text{def}}\) with \(h(G) \geq 1\), the weight is at least \(d\). This is derived from Lemma 2’s spaceDistanceBound_no_reduction.
This follows directly from spaceDistanceBound_no_reduction.
1.17.4 Cleaning Preserves Weight
The cleaning process using spacetime stabilizers does not reduce fault weight.
For a fault \(F\) and qubit \(q\), the fault parity at position counts the parity of space faults at qubit \(q\):
No proof needed for definitions.
For time faults and measurement index \(\text{idx}\), the time fault parity at index is:
No proof needed for definitions.
For any finite sets \(A\) and \(B\), \(|A \triangle B| \geq |A| - |B|\).
This is used in cleaning: when we multiply a fault \(F\) by a stabilizer \(S\), the new fault is \(F \triangle S\) (symmetric difference), and we need to track how the weight changes.
We have \(A \setminus B \subseteq (A \setminus B) \cup (B \setminus A) = A \triangle B\). Therefore \(|A \triangle B| \geq |A \setminus B|\). Since \(|A \setminus B| + |A \cap B| = |A|\) and \(|A \cap B| \leq |B|\), we get \(|A \setminus B| \geq |A| - |B|\). Combining these gives the result.
For spacetime faults \(F\) and \(S\):
This follows directly from the symmetric difference cardinality bound applied to \(F.\text{spaceFaults}\) and \(S.\text{spaceFaults}\).
Let \(F\) and \(S\) be spacetime faults where \(S\) is a stabilizer with even contribution at each qubit (i.e., for all \(q\), \(|S.\text{spaceFaults}.\text{filter}(\lambda f. f.\text{qubit} = q)|\) is even). Then for all qubits \(q\):
Mathematically: at each qubit \(q\), the parity \((F_q + S_q) \mod 2 = F_q \mod 2\) when \(S_q \equiv 0 \pmod{2}\) (stabilizer property).
Let \(q\) be arbitrary. Let \(F_q := F.\text{spaceFaults}.\text{filter}(\lambda f. f.\text{qubit} = q)\) and \(S_q := S.\text{spaceFaults}.\text{filter}(\lambda f. f.\text{qubit} = q)\).
First, we show that \((F.\text{spaceFaults} \triangle S.\text{spaceFaults}).\text{filter}(\lambda f. f.\text{qubit} = q) = F_q \triangle S_q\) by showing membership equivalence: \(f\) is in the left side if and only if \(f\) is in \(F.\text{spaceFaults} \triangle S.\text{spaceFaults}\) and \(f.\text{qubit} = q\), which is equivalent to \((f \in F_q \land f \notin S_q) \lor (f \in S_q \land f \notin F_q)\), which is exactly \(f \in F_q \triangle S_q\).
Next, we use the cardinality formula: \(|F_q \triangle S_q| = |F_q| + |S_q| - 2|F_q \cap S_q|\).
Since \(|S_q|\) is even by hypothesis, \((|S_q| : \mathbb {Z}/2\mathbb {Z}) = 0\). Also, \((2|F_q \cap S_q| : \mathbb {Z}/2\mathbb {Z}) = 0\) since \(2 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
Therefore:
For any spacetime fault \(F\): \(|F.\text{spaceFaults}| \leq \text{weight}(F)\).
By definition, \(\text{weight}(F) = |F.\text{spaceFaults}| + |F.\text{timeFaults}|\). By integer arithmetic, \(|F.\text{spaceFaults}| \leq |F.\text{spaceFaults}| + |F.\text{timeFaults}|\).
1.17.5 Space Fault to Check Connection
This establishes the connection between a SpaceTimeFault’s space component and the code distance property.
Let \(C\) be a stabilizer code with distance \(d\). Let \(\text{spaceFaults}\) be a non-empty set of space faults such that:
The check \(\text{spaceFaultsToCheck}(\text{spaceFaults})\) commutes with all code checks
The check \(\text{spaceFaultsToCheck}(\text{spaceFaults})\) is not a stabilizer element
Then \(\text{weight}(\text{spaceFaultsToCheck}(\text{spaceFaults})) \geq d\).
This is derived from the code distance property: operators that commute with all checks but are not stabilizers are non-trivial logicals, which have weight \(\geq d\).
This follows directly from the distance bound property of the stabilizer code with distance.
For a set of space faults:
The weight of the check is bounded by twice the number of distinct qubits affected.
Let \(\text{suppX}\) be the set of qubits where the X-type count is odd, and \(\text{suppZ}\) be the set of qubits where the Z-type count is odd. The weight equals \(|\text{suppX} \cup \text{suppZ}|\).
Both \(\text{suppX}\) and \(\text{suppZ}\) are subsets of \(\text{spaceFaults}.\text{image}(\lambda f. f.\text{qubit})\): if a qubit has odd X-count, there must be at least one fault at that qubit, and similarly for Z-count.
Therefore \(|\text{suppX}| \leq |\text{spaceFaults}.\text{image}(\lambda f. f.\text{qubit})|\) and \(|\text{suppZ}| \leq |\text{spaceFaults}.\text{image}(\lambda f. f.\text{qubit})|\). By the union bound, \(|\text{suppX} \cup \text{suppZ}| \leq |\text{suppX}| + |\text{suppZ}| \leq 2 \cdot |\text{spaceFaults}.\text{image}(\lambda f. f.\text{qubit})|\).
For any set of space faults: \(|\text{spaceFaults}.\text{image}(\lambda f. f.\text{qubit})| \leq |\text{spaceFaults}|\).
This follows from the standard fact that \(|\text{image}(S)| \leq |S|\) for finite sets.
If \(F.\text{spaceFaults}\) is non-empty, then \(F\) is not a pure time fault.
Assume for contradiction that \(F\) is a pure time fault, i.e., \(F.\text{spaceFaults} = \emptyset \). Then \(F.\text{spaceFaults}\) is empty, contradicting the hypothesis that it is non-empty.
1.17.6 Full Fault Tolerance Configuration
A full fault tolerance configuration consists of:
A distance configuration (including the gauging graph)
Condition (i): The Cheeger condition \(h(G) \geq 1\)
The number of measurement types
A set of detectors for syndrome extraction
A code deformation interval \([t_i, t_o]\)
Condition (ii): The round condition \(t_o - t_i \geq d\)
No proof needed for definitions.
The stabilizer code extracted from a full fault tolerance configuration.
No proof needed for definitions.
The deformed code configuration extracted from a full fault tolerance configuration.
No proof needed for definitions.
1.17.7 Space Bound from Cheeger Condition
When \(h(G) \geq 1\), any logical operator on the deformed code has weight \(\geq d\). This is the KEY connection that derives the space bound from the Cheeger condition, rather than assuming it as a hypothesis.
This follows directly from spaceDistanceBound_no_reduction.
If \(F\) is not a pure time fault, then \(|F.\text{spaceFaults}| {\gt} 0\).
If \(F\) is not a pure time fault, then by definition \(F.\text{spaceFaults} \neq \emptyset \). A finite set is non-empty if and only if its cardinality is positive.
1.17.8 Logical Fault Space Check Weight
For a stabilizer code with distance \(d\) and a spacetime fault \(F\): if the space faults commute with the code and are not a stabilizer, then \(\text{weight}(\text{spaceFaultsToCheck}(F.\text{spaceFaults})) \geq d\).
This lemma shows that non-pure-time logical faults have space weight \(\geq d\) because their space component corresponds to a non-trivial logical operator.
The space faults are NOT in the stabilizer group. This is exactly what we need: a non-stabilizer operator that commutes with checks must have weight \(\geq d\) by the code distance property. This follows directly from the distance bound of the stabilizer code.
1.17.9 Main Theorems
Given a pure time fault \(F\) satisfying the Lemma 5 conditions (no comparison detector violations and odd time fault count at some position in the interval), if \(\text{numRounds} \geq d\), then \(\text{weight}(F) \geq d\).
This is the first case of the main theorem, handling pure time faults.
By pure_time_fault_weight_ge_rounds, \(\text{weight}(F) \geq \text{numRounds}\). Since \(\text{numRounds} \geq d\) by hypothesis (the rounds condition from the configuration), transitivity gives \(\text{weight}(F) \geq d\).
Given a fault \(F\) with space component where the space faults commute with code and are not a stabilizer, the weight is at least \(d\).
This is the second case of the main theorem. The key insight is that the space bound is DERIVED from the code distance property.
Step 1: The check weight is \(\geq d\) by the code distance property. Since the space faults commute with all checks but are not stabilizers, they form a non-trivial logical operator.
Step 2: The check weight is bounded by the number of affected qubits. The X-support and Z-support are both subsets of the set of qubits that have at least one fault. Each affected qubit contributes at most 1 to the union.
Step 3: The number of affected qubits \(\leq \) number of space faults (by the image cardinality bound).
Step 4: \(|F.\text{spaceFaults}| \leq \text{weight}(F)\) by cleaning_to_space_only.
Chaining these inequalities: \(d \leq \text{check weight} \leq |\text{affected qubits}| \leq |F.\text{spaceFaults}| \leq \text{weight}(F)\).
For a deformed logical operator \(L_{\text{def}}\) in a full fault tolerance configuration (which includes \(h(G) \geq 1\)), the weight is at least \(d\).
This follows directly from spaceDistanceBound_no_reduction applied with the Cheeger condition from the configuration.
For a deformed logical operator \(L_{\text{def}}\), the weight of its original (non-edge) part is at least \(d\) when \(h(G) \geq 1\).
We first note that the total weight \(L_{\text{def}}.\text{weight} \geq d\) by deformed_logical_space_bound. The key insight comes from the proof in Lemma 2: the restriction to original qubits is an original code logical, which has weight \(\geq d\) by restriction_weight_ge_distance.
1.17.10 Spacetime Fault Distance Bounds
For a pure time logical fault \(F\) satisfying the Lemma 5 conditions, \(\text{weight}(F) \geq d\).
This follows directly from faultTolerance_time_case.
For a logical fault \(F\) with space component (not pure time), if the space faults commute with the code and are not stabilizers, then \(\text{weight}(F) \geq d\).
This follows directly from faultTolerance_space_case.
1.17.11 Achievability
The bound \(d_{ST} \geq d\) is tight when \(\text{numRounds} = d\). If there exist logical faults and a minimum-weight logical fault has weight exactly \(d\), and all logical faults have weight \(\geq d\), then \(d_{ST} = d\).
We prove both directions:
Upper bound: \(d_{ST} \leq d\). Let \(F\) be a witness with \(\text{weight}(F) = d\) and \(F\) is a logical fault. By spacetimeFaultDistance_le_weight, \(d_{ST} \leq \text{weight}(F) = d\).
Lower bound: \(d_{ST} \geq d\). By spacetimeFaultDistance_is_min, there exists a minimum-weight logical fault \(F_{\text{min}}\) with \(\text{weight}(F_{\text{min}}) = d_{ST}\). By hypothesis, all logical faults have weight \(\geq d\), so \(d_{ST} = \text{weight}(F_{\text{min}}) \geq d\).
By antisymmetry, \(d_{ST} = d\).
1.17.12 Summary Theorem
Under conditions (i) \(h(G) \geq 1\) and (ii) \(t_o - t_i \geq d\):
Time bound applies: For all pure time faults \(F\) satisfying the Lemma 5 conditions, \(\text{weight}(F) \geq \text{numRounds}\).
Time bound implies \(d\) bound: If \(\text{weight}(F) \geq \text{numRounds}\) and \(\text{numRounds} \geq d\), then \(\text{weight}(F) \geq d\).
Space component contributes: For all \(F\), \(|F.\text{spaceFaults}| \leq \text{weight}(F)\).
We prove each part:
Part 1: Let \(F\) be a pure time fault satisfying the conditions. By time_distance_bound, \(\text{weight}(F) \geq \text{numRounds}\).
Part 2: Let \(F\) be such that \(\text{weight}(F) \geq \text{numRounds}\). Since \(\text{numRounds} \geq d\), transitivity gives \(\text{weight}(F) \geq d\).
Part 3: By definition, \(\text{weight}(F) = |F.\text{spaceFaults}| + |F.\text{timeFaults}|\). By integer arithmetic, \(|F.\text{spaceFaults}| \leq \text{weight}(F)\).
1.17.13 Helper Lemmas
For any spacetime fault \(F\): either \(F\) is space-only, or \(F.\text{timeFaults}\) is non-empty.
We consider whether \(F.\text{timeFaults} = \emptyset \). If yes, then \(F\) is space-only by definition. If no, then \(F.\text{timeFaults}\) is non-empty.
For any spacetime fault \(F\): either \(F\) is time-only, or \(F.\text{spaceFaults}\) is non-empty.
We consider whether \(F.\text{spaceFaults} = \emptyset \). If yes, then \(F\) is time-only by definition. If no, then \(F.\text{spaceFaults}\) is non-empty.
The empty fault is space-only.
By definition of the empty fault, \(\text{timeFaults} = \emptyset \). By definition of space-only, this means the empty fault is space-only.
The empty fault is time-only.
By definition of the empty fault, \(\text{spaceFaults} = \emptyset \). By definition of time-only, this means the empty fault is time-only.
If \(F.\text{spaceFaults}\) is non-empty, then \(F\) is not a pure time fault.
Assume for contradiction that \(F\) is a pure time fault. Then by definition, \(F.\text{spaceFaults} = \emptyset \). But \(\emptyset \) is not non-empty, contradicting the hypothesis.
If \(F.\text{timeFaults}\) is non-empty, then \(F\) is not space-only.
Assume for contradiction that \(F\) is space-only. Then by definition, \(F.\text{timeFaults} = \emptyset \). But \(\emptyset \) is not non-empty, contradicting the hypothesis.
The distance parameter of fault tolerance parameters is non-negative: \(0 \leq d\).
This holds by the fact that natural numbers are non-negative.
The number of rounds is non-negative: \(0 \leq \text{numRounds}\).
This holds by the fact that natural numbers are non-negative.
1.17.14 Distance Preservation with Cheeger Condition
When \(h(G) \geq 1\), the distance is preserved: \(\text{cheegerFactor}(G) \cdot d = d\).
By cheegerFactor_one_of_condition, \(\text{cheegerFactor}(G) = 1\). Therefore \(\text{cheegerFactor}(G) \cdot d = 1 \cdot d = d\).
The Cheeger condition is equivalent to \(h(G) \geq 1\): \(\text{satisfiesCheegerCondition}(G) \Leftrightarrow h(G) \geq 1\).
This holds by reflexivity of the definition.
This version explicitly takes a DistanceConfig with \(h(G) \geq 1\) and derives the space distance bound from Lemma 2. When \(h(G) \geq 1\), any DeformedLogicalOperator has weight \(\geq d\).
This follows directly from spaceDistanceBound_no_reduction.
1.17.15 Main Theorem
Main Theorem (Theorem 2): Fault Tolerance
Given:
A stabilizer code \(C\) with distance \(d\)
A gauging graph \(G\) with \(h(G) \geq 1\) (Condition i)
A code deformation interval with \(t_o - t_i \geq d\) (Condition ii)
Then: For any spacetime logical fault \(F\), \(\text{weight}(F) \geq d\).
Proof Structure:
Pure time faults: By Lemma 5 + condition (ii)
Faults with space component: By code distance property
We proceed by case analysis on whether \(F\) is a pure time fault.
Case 1: Pure time fault. If \(F\) is a pure time fault, then by hypothesis it satisfies the Lemma 5 conditions (no comparison detector violations and odd count at some position). We apply faultTolerance_time_case to get \(\text{weight}(F) \geq d\).
Case 2: Has space component. If \(F\) is not a pure time fault, then by hypothesis the space faults commute with the code and are not stabilizers. We apply faultTolerance_space_case to get \(\text{weight}(F) \geq d\).
In both cases, \(\text{weight}(F) \geq d\).
Under conditions (i) and (ii), the spacetime fault distance satisfies \(d_{ST} \geq d\).
By spacetimeFaultDistance_is_min, there exists a minimum-weight logical fault \(F_{\text{min}}\) with \(\text{weight}(F_{\text{min}}) = d_{ST}\).
We extract the conditions for \(F_{\text{min}}\) from the hypothesis and apply faultTolerance_main to get \(\text{weight}(F_{\text{min}}) \geq d\).
Since \(d_{ST} = \text{weight}(F_{\text{min}}) \geq d\), we have \(d_{ST} \geq d\).
[High Weight Flux Checks]
The fault-distance result (Theorem 2) holds even if:
The flux checks \(B_p\) have high weight
The \(B_p\) checks are measured infrequently (less than every time step)
The \(B_p\) detectors are only inferred once via initialization and final read-out
Reason: The proof of Theorem 2 only requires:
\(A_v\) syndromes to be local and frequently measured
Deformed checks \(\tilde{s}_j\) to be frequently measured
\(B_p\) information to be inferable (not necessarily directly measured)
Caveat: Without frequent \(B_p\) measurements, the decoder has large detector cells for \(B_p\) syndromes. This likely prevents a threshold against uncorrelated noise, but may still be useful for small fixed-size instances.
No proof needed for remarks.
Classification of check types by measurement requirements. The key insight of Remark 17 is that different check types have different measurement requirements for the fault distance bound:
\(A_v\) (Gauss law): Must be local and frequently measured
\(\tilde{s}_j\) (Deformed): Must be frequently measured
\(B_p\) (Flux): Information only needs to be inferable
The fault distance bound depends on \(A_v\) and \(\tilde{s}_j\), not directly on \(B_p\).
The type has three constructors:
gaussLaw: Gauss law checks \(A_v\) (local, must be measured frequently)
deformedCheck: Deformed checks \(\tilde{s}_j\) (must be measured frequently)
fluxCheck: Flux checks \(B_p\) (only need to be inferable, not directly measured)
There are exactly 3 check measurement types:
This holds by reflexivity (definitional equality).
A predicate indicating whether a check type requires frequent measurement for Theorem 2:
\(\texttt{gaussLaw} \mapsto \texttt{true}\) (\(A_v\) must be measured frequently)
\(\texttt{deformedCheck} \mapsto \texttt{true}\) (\(\tilde{s}_j\) must be measured frequently)
\(\texttt{fluxCheck} \mapsto \texttt{false}\) (\(B_p\) only needs to be inferable)
A predicate indicating whether a check type requires locality for Theorem 2:
\(\texttt{gaussLaw} \mapsto \texttt{true}\) (\(A_v\) must be local)
\(\texttt{deformedCheck} \mapsto \texttt{true}\) (\(\tilde{s}_j\) should be local for efficient syndrome extraction)
\(\texttt{fluxCheck} \mapsto \texttt{false}\) (\(B_p\) can be high weight)
The set of check types that require frequent measurement:
The set of check types that require locality:
The proof of Theorem 2 only requires \(A_v\) and \(\tilde{s}_j\) properties. The exact set of frequently measured check types is:
This holds by reflexivity (definitional equality).
Flux checks are NOT in the set of required measurements. This is the formal statement of the remark’s key insight:
By simplification using the definition of frequentlyMeasuredChecks, we have that \(x \in \texttt{frequentlyMeasuredChecks}\) iff \(x = \texttt{gaussLaw}\) or \(x = \texttt{deformedCheck}\). Assume \(\texttt{fluxCheck} \in \texttt{frequentlyMeasuredChecks}\). We consider two cases: if \(\texttt{fluxCheck} = \texttt{gaussLaw}\), this contradicts the distinctness of constructors. Similarly, if \(\texttt{fluxCheck} = \texttt{deformedCheck}\), this also contradicts constructor distinctness.
Gauss law checks require frequent measurement:
This holds by reflexivity (definitional equality).
Deformed checks require frequent measurement:
This holds by reflexivity (definitional equality).
Flux checks do NOT require frequent measurement:
This holds by reflexivity (definitional equality).
The required check types are exactly those where requiresFrequentMeasurement is true:
Let \(x\) be arbitrary. By simplification using the definition of frequentlyMeasuredChecks, membership is equivalent to \(x = \texttt{gaussLaw}\) or \(x = \texttt{deformedCheck}\).
For the forward direction, assume \(x \in \texttt{frequentlyMeasuredChecks}\). We consider two cases: if \(x = \texttt{gaussLaw}\), then by rewriting, \(\texttt{requiresFrequentMeasurement}(\texttt{gaussLaw}) = \texttt{true}\) holds by definition. Similarly for \(x = \texttt{deformedCheck}\).
For the backward direction, assume \(\texttt{requiresFrequentMeasurement}(x) = \texttt{true}\). We perform case analysis on \(x\): for gaussLaw, we have \(x = \texttt{gaussLaw}\) which is in the set. For deformedCheck, we have \(x = \texttt{deformedCheck}\) which is in the set. For fluxCheck, by definition \(\texttt{requiresFrequentMeasurement}(\texttt{fluxCheck}) = \texttt{false}\), contradicting our assumption.
\(B_p\) properties don’t affect requirements. No matter what \(B_p\)’s weight or measurement frequency, it remains outside the required set:
All three conjuncts follow directly from the theorem that \(B_p\) is not in the requirements (Bp_not_in_requirements).
A measurement schedule describes how each check type is measured. The key insight: only \(A_v\) and \(\tilde{s}_j\) need to be measured every round. \(B_p\) can be measured infrequently or only inferred from initialization/readout.
A measurement schedule consists of:
gaussLaw_period: Measurement period for \(A_v\) (in rounds); 1 = every round
deformedCheck_period: Measurement period for \(\tilde{s}_j\) (in rounds); 1 = every round
fluxCheck_period: Measurement period for \(B_p\) (in rounds); can be \({\gt} 1\) or even \(0\) (inferred-only)
gaussLaw_frequent: Proof that \(A_v\) must be measured every round (period = 1)
deformedCheck_frequent: Proof that \(\tilde{s}_j\) must be measured every round (period = 1)
A standard measurement schedule where all checks are measured every round:
\(\texttt{gaussLaw\_ period} = 1\)
\(\texttt{deformedCheck\_ period} = 1\)
\(\texttt{fluxCheck\_ period} = 1\)
A flexible schedule where \(B_p\) is measured every \(k\) rounds:
\(\texttt{gaussLaw\_ period} = 1\)
\(\texttt{deformedCheck\_ period} = 1\)
\(\texttt{fluxCheck\_ period} = k\)
An inferred-only schedule where \(B_p\) is only measured at initialization and final readout:
\(\texttt{gaussLaw\_ period} = 1\)
\(\texttt{deformedCheck\_ period} = 1\)
\(\texttt{fluxCheck\_ period} = 0\) (0 represents “never during computation”)
All schedules satisfy the Theorem 2 requirements (\(A_v\) and \(\tilde{s}_j\) frequent):
This follows directly from the structure fields gaussLaw_frequent and deformedCheck_frequent which are part of the MeasurementSchedule definition.
The \(B_p\) period can vary without affecting requirements:
Both equalities hold by reflexivity since the gaussLaw_period and deformedCheck_period fields are always 1 in flexibleSchedule, independent of the parameter \(k\).
The fault distance bound (from Theorem 2) depends only on:
The time distance (Lemma 5) from \(A_v\) comparison detectors
The space distance (Lemma 2) from the gauging graph structure
Neither component uses \(B_p\) weight. Formally:
All three equalities hold by reflexivity (definitional equality).
A detector cell is the spacetime region corresponding to a detector. For \(B_p\) with period \(T\), the detector cell spans \(T\) time steps.
A detector cell consists of:
spatialSize: Spatial extent (number of qubits involved)
temporalSize: Temporal extent (number of time steps)
volume: Total spacetime volume
volume_eq: Proof that \(\texttt{volume} = \texttt{spatialSize} \times \texttt{temporalSize}\)
A standard detector cell with single-round, local structure:
\(\texttt{spatialSize} = w\) (the spatial weight parameter)
\(\texttt{temporalSize} = 1\)
\(\texttt{volume} = w\)
A large detector cell from infrequent \(B_p\) measurement:
\(\texttt{spatialSize} = w\) (the spatial weight parameter)
\(\texttt{temporalSize} = p\) (the period parameter)
\(\texttt{volume} = w \cdot p\)
Cell volume grows linearly with measurement period:
This holds by reflexivity (definitional equality).
Detector cell volume is proportional to temporal period. When \(B_p\) is measured every period rounds, the detector cell captures period times as many potential errors:
By simplification using the definition of largeCell, both sides equal \(w \cdot p_1 \cdot p_2\). This follows by ring arithmetic.
With measurement period \(T\) instead of 1, the detector cell volume increases by factor \(T\). This means up to \(T\) times as many errors can occur within a single detector’s region.
For uncorrelated noise with error rate \(p\), the probability of \(\geq 2\) errors in a cell of volume \(V\) is approximately \(V^2 p^2\). Larger \(V\) makes multi-error events more likely, preventing error threshold.
Formally, given \(\texttt{period} {\gt} 1\) and \(\texttt{spatialWeight} \geq 1\):
We prove each conjunct:
For the first conjunct (volume comparison): By unfolding definitions, we need \(w \cdot p {\gt} w\). Since \(p \geq 2\) (from \(p {\gt} 1\)), we have \(w \cdot p \geq w \cdot 2 = w + w {\gt} w\) (using \(w \geq 1\)).
For the second conjunct (temporal extent comparison): By unfolding definitions, \(p {\gt} 1\) follows directly from the hypothesis.
For the third conjunct (volume ratio): By unfolding definitions, \(w \cdot p = p \cdot w\) follows by ring arithmetic.
For an instance of size \(n\) with \(T\) rounds and error rate \(p\), the expected number of errors is at most \(n \cdot T \cdot p\). For small instances, this remains bounded even without threshold protection:
when \(\texttt{errorRate} \leq 100\).
This follows directly from monotonicity of multiplication: \(\texttt{errorRate} \leq 100\) implies \(\texttt{instanceSize} \cdot \texttt{rounds} \cdot \texttt{errorRate} \leq \texttt{instanceSize} \cdot \texttt{rounds} \cdot 100\).
For small fixed-size instances with bounded total errors, the fault distance provides protection even without threshold. If total errors \({\lt} d\), no logical fault can occur (since logical faults have weight \(\geq d\) by Theorem 2):
This follows directly from the hypothesis.
The protection is meaningful when expected errors \({\lt} d/2\) (majority rule):
By integer arithmetic (omega), \(2 \cdot \texttt{expectedErrors} {\lt} d\) implies \(\texttt{expectedErrors} {\lt} d\).
Mode of \(B_p\) information acquisition:
directEveryRound: \(B_p\) directly measured every round
directPeriodic\((p, h)\): \(B_p\) measured every \(p {\gt} 1\) rounds
inferredOnly: \(B_p\) inferred from initialization + final readout
All modes provide the same requirement satisfaction (\(A_v\) and \(\tilde{s}_j\) frequent). The mode only affects \(B_p\), which is not required:
This follows directly from the theorem that \(B_p\) is not in the requirements.
The logical measurement outcome \(\sigma = \prod _v \varepsilon _v\) is determined purely by \(A_v\) syndrome products. \(B_p\) constrains the valid syndrome space but does not determine the logical measurement outcome:
Both equalities hold by reflexivity (definitional equality).
The standard schedule has Gauss law period 1:
This holds by reflexivity (definitional equality).
The standard schedule has deformed check period 1:
This holds by reflexivity (definitional equality).
The flexible schedule maintains required measurements:
Both equalities hold by reflexivity (definitional equality).
The inferred-only schedule maintains required measurements:
Both equalities hold by reflexivity (definitional equality).
Check measurement types have exactly 3 elements:
This holds by reflexivity (definitional equality).
Only the flux check can be flexible (not required to be frequent):
By simplification using the definition of requiresFrequentMeasurement, all three conditions reduce to trivially true statements.
Detector cell volume is positive when both dimensions are positive:
Rewriting using \(c.\texttt{volume} = c.\texttt{spatialSize} \times c.\texttt{temporalSize}\), the result follows from the fact that \(a \geq 1 \land b \geq 1 \Rightarrow a \cdot b \geq 1\) for natural numbers.
Standard cells have unit temporal size:
This holds by reflexivity (definitional equality).
Large cells have specified temporal size:
This holds by reflexivity (definitional equality).
The number of required check types is 2 (\(A_v\) and \(\tilde{s}_j\)):
This holds by reflexivity (definitional equality).
The number of flexible check types is 1 (\(B_p\) only):
This holds by reflexivity (definitional equality).
1.18 Boundary Conditions (Remark 18)
The \(d\) rounds of error correction in the original code before time \(t_i\) and after time \(t_o\) serve to establish clean boundary conditions for the fault-tolerance proof.
Purpose: Ensure that any fault pattern involving both:
The gauging measurement (\(t_i\) to \(t_o\)), and
The initial or final boundary
has total weight \({\gt} d\).
Practical consideration: In a larger fault-tolerant computation, the gauging measurement is one component among many. The number of rounds before/after can be reduced based on the surrounding operations, but this may affect the effective distance and threshold.
Idealization: The proof assumes the first and last measurement rounds are perfect. This is a common proof technique and doesn’t fundamentally change the results, given the \(d\) buffer rounds.
1.18.1 Boundary Configuration
A boundary configuration models the \(d\) rounds of buffer error correction before and after code deformation. It consists of:
numBufferRounds: The number of buffer rounds (equals code distance \(d\))
interval: The code deformation interval \([t_i, t_o]\)
preGaugingStart: The start of the pre-gauging buffer period
postGaugingEnd: The end of the post-gauging buffer period
Subject to the constraints:
Pre-gauging buffer ends at \(t_i\): \(\texttt{preGaugingStart} + \texttt{numBufferRounds} = t_i\)
Post-gauging buffer starts at \(t_o\): \(t_o + \texttt{numBufferRounds} = \texttt{postGaugingEnd}\)
The gauging measurement interval \([t_i, t_o]\) for a boundary configuration \(bc\) is simply \(bc.\text{interval}\).
The total duration including buffer rounds is:
This equals \(2d + (t_o - t_i)\) for standard configurations.
The gauging period duration is \(t_o - t_i\), i.e., \(bc.\text{interval}.\text{numRounds}\).
The standard boundary configuration with \(d\) buffer rounds and base time \(t_{\text{base}}\) has:
\(\texttt{numBufferRounds} = d\)
\(\texttt{interval} = [t_{\text{base}} + d, t_{\text{base}} + 2d]\)
\(\texttt{preGaugingStart} = t_{\text{base}}\)
\(\texttt{postGaugingEnd} = t_{\text{base}} + 3d\)
For the standard configuration with parameter \(d\):
This holds by reflexivity from the definition.
For the standard configuration:
This holds by reflexivity from the definition.
For the standard configuration:
By simplification using the definitions of standard and CodeDeformationInterval.ofDuration.
1.18.2 Extended Interval and Region Classification
The extended interval including buffer regions is:
The pre-buffer interval is \([\texttt{preGaugingStart}, t_i)\).
The number of rounds in the pre-buffer interval equals \(\texttt{numBufferRounds} = d\):
Unfolding the definitions of preBufferInterval and numRounds, we have:
From the constraint \(\texttt{preGaugingStart} + \texttt{numBufferRounds} = t_i\), we rewrite this as:
using the natural number subtraction cancellation lemma.
The post-buffer interval is \((t_o, \texttt{postGaugingEnd}]\).
The number of rounds in the post-buffer interval equals \(\texttt{numBufferRounds} = d\):
Unfolding the definitions, we have:
From the constraint \(t_o + \texttt{numBufferRounds} = \texttt{postGaugingEnd}\), we rewrite this as:
using the natural number subtraction cancellation lemma.
A time region classification for fault locations:
preBuffer: Pre-gauging buffer \([\texttt{preGaugingStart}, t_i)\)
gauging: Gauging measurement period \([t_i, t_o]\)
postBuffer: Post-gauging buffer \((t_o, \texttt{postGaugingEnd}]\)
There are exactly 3 time regions:
This holds by reflexivity since TimeRegion has exactly three constructors.
Classify a time step \(t\) into its region:
A time step \(t\) is in the gauging region if \(t_i \leq t \leq t_o\).
A time step \(t\) is in the pre-buffer region if \(\texttt{preGaugingStart} \leq t {\lt} t_i\).
A time step \(t\) is in the post-buffer region if \(t_o {\lt} t \leq \texttt{postGaugingEnd}\).
1.18.3 Chain Coverage Extended to Buffer Regions
The pre-to-gauging interval is the combined interval \([\texttt{preGaugingStart}, t_o]\) that must be covered by a chain crossing the initial boundary.
The number of rounds from \(\texttt{preGaugingStart}\) to \(t_o\) equals \(d + (t_o - t_i)\):
Unfolding the definitions, we need to show:
From \(\texttt{preGaugingStart} + \texttt{numBufferRounds} = t_i\), we have \(t_i - \texttt{preGaugingStart} = \texttt{numBufferRounds}\).
By arithmetic:
The gauging-to-post interval is the combined interval \([t_i, \texttt{postGaugingEnd}]\) for final boundary crossing.
The number of rounds from \(t_i\) to \(\texttt{postGaugingEnd}\) equals \((t_o - t_i) + d\):
Unfolding the definitions, we need to show:
From \(t_o + \texttt{numBufferRounds} = \texttt{postGaugingEnd}\), we have \(\texttt{postGaugingEnd} - t_o = \texttt{numBufferRounds}\).
By arithmetic:
1.18.4 Main Theorem - Boundary-Crossing Faults Exceed Distance \(d\)
An initial boundary crossing fault is a spacetime fault that:
Has at least one fault in the pre-buffer region: \(\exists f \in \text{timeFaults}\), \(\texttt{preGaugingStart} \leq f.\text{measurementRound} {\lt} t_i\)
Has at least one fault in the gauging region: \(\exists f \in \text{timeFaults}\), \(t_i \leq f.\text{measurementRound} {\lt} t_o\)
Covers all rounds from \(\texttt{preGaugingStart}\) to \(t_o\) (chain property from Lemma 5)
An initial boundary-crossing fault (that forms a valid chain) has weight \({\gt} d\), where \(d = \texttt{numBufferRounds}\) is the code distance.
Formally, if \(cf\) is an initial boundary crossing fault for configuration \(bc\) and the gauging interval has positive duration (\(bc.\text{interval}.\texttt{numRounds} {\gt} 0\)), then:
The fault covers all rounds in \([\texttt{preGaugingStart}, t_o)\). Let \(\texttt{hcover}\) denote this coverage property. By the theorem timeFaults_cover_implies_weight_bound, we have:
By the pre-to-gauging interval number of rounds lemma:
Therefore:
where the last inequality uses that \(\text{interval}.\texttt{numRounds} {\gt} 0\).
A final boundary crossing fault is a spacetime fault that:
Has at least one fault in the gauging region: \(\exists f \in \text{timeFaults}\), \(t_i \leq f.\text{measurementRound} {\lt} t_o\)
Has at least one fault in the post-buffer region: \(\exists f \in \text{timeFaults}\), \(t_o \leq f.\text{measurementRound} {\lt} \texttt{postGaugingEnd}\)
Covers all rounds from \(t_i\) to \(\texttt{postGaugingEnd}\) (chain property from Lemma 5)
A final boundary-crossing fault (that forms a valid chain) has weight \({\gt} d\), where \(d = \texttt{numBufferRounds}\) is the code distance.
Formally, if \(cf\) is a final boundary crossing fault for configuration \(bc\) and the gauging interval has positive duration, then:
The fault covers all rounds in \([t_i, \texttt{postGaugingEnd})\). By the theorem timeFaults_cover_implies_weight_bound:
By the gauging-to-post interval number of rounds lemma:
Therefore:
where the last inequality uses that \(\text{interval}.\texttt{numRounds} {\gt} 0\).
A boundary crossing fault is either an initial or final boundary crossing fault.
Extract the underlying spacetime fault from a boundary-crossing fault.
Any boundary-crossing fault (that satisfies the chain coverage property from Lemma 5) has weight \({\gt} d\), where \(d = \texttt{numBufferRounds}\) is the code distance.
This formalizes: “any fault pattern involving both the gauging measurement AND the initial or final boundary has total weight \({\gt} d\).”
We consider two cases based on whether \(cf\) is an initial or final boundary crossing fault:
Case initial: Apply initial_boundary_crossing_weight_exceeds_d.
Case final: Apply final_boundary_crossing_weight_exceeds_d.
1.18.5 Internal Faults
A fault \(F\) is internal to the gauging period if all time faults satisfy \(t_i \leq f.\text{measurementRound} {\lt} t_o\).
Internal faults have no time faults in the pre-buffer region:
Let \(f \in F.\text{timeFaults}\) and suppose \(f.\text{measurementRound} {\lt} t_i\). From the internal property, we have \(t_i \leq f.\text{measurementRound}\). This contradicts \(f.\text{measurementRound} {\lt} t_i\).
Internal faults have no time faults in the post-buffer region:
Let \(f \in F.\text{timeFaults}\) and suppose \(t_o \leq f.\text{measurementRound}\). From the internal property, we have \(f.\text{measurementRound} {\lt} t_o\). This contradicts \(t_o \leq f.\text{measurementRound}\).
1.18.6 Idealization - Perfect Boundary Assumption
The perfect boundary assumption states that no faults occur at exact boundaries:
No time faults at exactly \(t_i\)
No time faults at exactly \(t_o\)
No space faults at exactly \(t_i\)
No space faults at exactly \(t_o\)
This is an idealization used in the proof technique.
The weight bound holds regardless of the perfect boundary assumption. Faults at the boundary still count toward total weight:
The \(d\) buffer rounds provide enough redundancy to handle boundary effects.
This holds by reflexivity from the definition of weight.
Any fault at the boundary contributes to weight (not ignored):
Since \(f \in \text{fault}.\text{timeFaults}\), the set is nonempty, so its cardinality is at least 1.
1.18.7 Practical Considerations
A reduced buffer configuration models the case when surrounding operations provide partial protection:
fullConfig: Full configuration with standard buffers
actualPreBuffer: Actual pre-buffer rounds used (\(\leq \texttt{numBufferRounds}\))
actualPostBuffer: Actual post-buffer rounds used (\(\leq \texttt{numBufferRounds}\))
The effective distance with reduced buffers is:
When buffers are reduced, the effective protection against boundary-crossing faults is diminished proportionally.
Reduced buffers may decrease effective distance:
Unfolding the definition of effective distance, we have:
where \(g\) is the gauging duration. The result follows since \(\min (a, \min (b, c)) \leq b\).
Full buffers preserve the original distance:
Since \(d \leq d + \text{interval}.\texttt{numRounds}\), we have \(\min (d, d + \text{interval}.\texttt{numRounds}) = d\).
1.18.8 Helper Lemmas
Time region classification is total: for any time step \(t\), one of the following holds:
\(t\) is in the pre-buffer region
\(t\) is in the gauging region
\(t\) is in the post-buffer region
\(t {\lt} \texttt{preGaugingStart}\)
\(t {\gt} \texttt{postGaugingEnd}\)
By case analysis on whether \(t {\lt} \texttt{preGaugingStart}\), \(t {\lt} t_i\), \(t \leq t_o\), and \(t \leq \texttt{postGaugingEnd}\). Each combination of these conditions leads to exactly one of the five cases.
Pre-buffer and gauging regions are disjoint:
Suppose both hold. Then \(t {\lt} t_i\) (from pre-buffer) and \(t_i \leq t\) (from gauging). This gives \(t {\lt} t_i \leq t\), a contradiction.
Gauging and post-buffer regions are disjoint:
Suppose both hold. Then \(t \leq t_o\) (from gauging) and \(t_o {\lt} t\) (from post-buffer). This gives \(t \leq t_o {\lt} t\), a contradiction.
Standard configuration has total duration \(3d\):
Unfolding the definitions of totalDuration and standard, we compute:
using the omega tactic for arithmetic.
Pre-buffer region is non-empty when buffer \({\gt} 0\):
From \(\texttt{preGaugingStart} + \texttt{numBufferRounds} = t_i\) and \(\texttt{numBufferRounds} {\gt} 0\):
Post-buffer region is non-empty when buffer \({\gt} 0\):
From \(t_o + \texttt{numBufferRounds} = \texttt{postGaugingEnd}\) and \(\texttt{numBufferRounds} {\gt} 0\):
The boundary configuration is well-formed:
We verify each inequality:
\(\texttt{preGaugingStart} \leq t_i\): From \(\texttt{preGaugingStart} + \texttt{numBufferRounds} = t_i\), we have \(\texttt{preGaugingStart} \leq \texttt{preGaugingStart} + \texttt{numBufferRounds} = t_i\).
\(t_i \leq t_o\): This is the start_le_end constraint on the interval.
\(t_o \leq \texttt{postGaugingEnd}\): From \(t_o + \texttt{numBufferRounds} = \texttt{postGaugingEnd}\), we have \(t_o \leq t_o + \texttt{numBufferRounds} = \texttt{postGaugingEnd}\).
1.19 Bivariate Bicycle Code (Definition 16)
[Bivariate Bicycle Code Setup]
Let \(\ell , m \in \mathbb {N}\) and define:
\(I_r\): the \(r \times r\) identity matrix
\(C_r\): the \(r \times r\) cyclic permutation matrix, \((C_r)_{ij} = [j \equiv i + 1 \pmod{r}]\)
\(x = C_\ell \otimes I_m\) and \(y = I_\ell \otimes C_m\)
The matrices \(x, y\) satisfy: \(x^\ell = y^m = I_{\ell m}\), \(xy = yx\), and \(x^T x = y^T y = I_{\ell m}\).
A Bivariate Bicycle (BB) code is a CSS code on \(n = 2\ell m\) physical qubits, divided into:
\(\ell m\) left (L) qubits
\(\ell m\) right (R) qubits
The parity check matrices are:
where \(A, B \in \mathbb {F}_2[x, y]\) are polynomials in \(x\) and \(y\) with coefficients in \(\mathbb {F}_2\).
Transpose convention: \(A^T = A(x, y)^T = A(x^{-1}, y^{-1})\) (inverse of \(x\) is \(x^{\ell -1}\), etc.)
Labeling: Checks and qubits are labeled by \((\alpha , T)\) for \(\alpha \in M = \{ x^a y^b : a, b \in \mathbb {Z}\} \) and \(T \in \{ X, Z, L, R\} \).
Check action:
\(X\) check \((\alpha , X)\) acts on qubits \((\alpha A, L)\) and \((\alpha B, R)\)
\(Z\) check \((\beta , Z)\) acts on qubits \((\beta B^T, L)\) and \((\beta A^T, R)\)
No proof needed for remarks.
1.19.1 Cyclic Permutation Matrix
The cyclic permutation matrix \(C_r\) is the \(r \times r\) matrix with \((C_r)_{ij} = 1\) if and only if \(j \equiv i + 1 \pmod{r}\). This represents a right cyclic shift.
The identity matrix \(I_r \in \mathbb {F}_2^{r \times r}\).
For all \(i \in \text{Fin}(r)\), there exists a unique \(j \in \text{Fin}(r)\) such that \((C_r)_{ij} = 1\).
Let \(i\) be arbitrary. We claim that \(j = \langle (i + 1) \mod r \rangle \) is the unique index with \((C_r)_{ij} = 1\). By the definition of \(C_r\), we have \((C_r)_{i,j} = 1\) since \(j = (i + 1) \mod r\). For uniqueness, suppose \((C_r)_{i,y} = 1\) for some \(y\). By the definition of \(C_r\), this means \(y = (i + 1) \mod r\), which by extensionality gives \(y = j\).
For all \(i \in \text{Fin}(r)\), \((C_r)_{i, \langle (i+1) \mod r \rangle } = 1\).
This holds by simplification using the definition of \(C_r\).
For \(i, j \in \text{Fin}(r)\) with \(j \neq (i + 1) \mod r\), we have \((C_r)_{ij} = 0\).
By the definition of \(C_r\), \((C_r)_{ij} = 0\) when \(j \neq (i + 1) \mod r\).
1.19.2 Qubit and Check Types
The qubit type is an inductive type with two constructors:
\(L\): Left qubit
\(R\): Right qubit
The check type is an inductive type with two constructors:
\(X\): \(X\)-type check
\(Z\): \(Z\)-type check
1.19.3 Monomial Index
A monomial index represents \(x^a y^b\) where \(a \in \mathbb {Z}_\ell \) and \(b \in \mathbb {Z}_m\). We use \(\text{Fin}(\ell ) \times \text{Fin}(m)\) to represent \((a, b)\). The structure consists of:
\(\texttt{xPow} : \text{Fin}(\ell )\) – Power of \(x\) (mod \(\ell \))
\(\texttt{yPow} : \text{Fin}(m)\) – Power of \(y\) (mod \(m\))
The identity monomial \(x^0 y^0\).
Multiplication of monomials: \(x^a y^b \cdot x^c y^d = x^{a+c} y^{b+d}\).
The monomial \(x = x^1 y^0\).
The monomial \(y = x^0 y^1\).
For all monomials \(\alpha , \beta \), we have \(\alpha \cdot \beta = \beta \cdot \alpha \).
By extensionality, it suffices to show equality of both components. By the definition of multiplication, the \(x\)-power of \(\alpha \cdot \beta \) is \(\alpha .\texttt{xPow} + \beta .\texttt{xPow}\), which equals \(\beta .\texttt{xPow} + \alpha .\texttt{xPow}\) by commutativity of addition. Similarly for the \(y\)-power.
For all monomials \(\alpha \), we have \(1 \cdot \alpha = \alpha \).
By simplification using the definitions of multiplication and identity, \(0 + \alpha .\texttt{xPow} = \alpha .\texttt{xPow}\) and similarly for the \(y\)-power.
For all monomials \(\alpha \), we have \(\alpha \cdot 1 = \alpha \).
By simplification using the definitions, \(\alpha .\texttt{xPow} + 0 = \alpha .\texttt{xPow}\) and similarly for the \(y\)-power.
The inverse of a monomial: \((x^a y^b)^{-1} = x^{-a} y^{-b} = x^{\ell -a} y^{m-b}\).
1.19.4 BB Polynomial
A polynomial in \(x\) and \(y\) with coefficients in \(\mathbb {F}_2\) is represented by a finite set of monomial indices (the support, where coefficient \(= 1\)). This represents \(\sum _{(a,b) \in S} x^a y^b\).
The zero polynomial with empty support.
The identity polynomial \(1 = x^0 y^0\) with support \(\{ (0, 0)\} \).
A single monomial \(x^a y^b\) as a polynomial.
The polynomial \(x = x^1 y^0\).
The polynomial \(y = x^0 y^1\).
Addition of polynomials is the symmetric difference (XOR) of supports in \(\mathbb {F}_2\).
Multiplication by a monomial shifts all exponents: \(\alpha \cdot A = \{ (a + \alpha _1, b + \alpha _2) : (a, b) \in A.\texttt{support}\} \).
The number of terms in a polynomial is the cardinality of its support.
For all polynomials \(A, B\), we have \(A + B = B + A\).
By the definition of addition, \((A + B).\texttt{support} = A.\texttt{support} \triangle B.\texttt{support}\). The result follows from the commutativity of symmetric difference.
For all polynomials \(A\), we have \(A + 0 = A\).
By extensionality on supports. For any \(x\), \(x \in A.\texttt{support} \triangle \emptyset \) if and only if \(x \in A.\texttt{support}\) and \(x \notin \emptyset \), which simplifies to \(x \in A.\texttt{support}\).
For all polynomials \(A\), we have \(A + A = 0\).
By the definition of addition, \((A + A).\texttt{support} = A.\texttt{support} \triangle A.\texttt{support} = \emptyset \) since the symmetric difference of a set with itself is empty.
1.19.5 Polynomial Transpose
The transpose of a polynomial: \(A(x,y)^T = A(x^{-1}, y^{-1})\). For a monomial \(x^a y^b\), the transpose is \(x^{-a} y^{-b} = x^{\ell -a} y^{m-b}\).
\(1^T = 1\).
By extensionality on supports. For \((a, b)\), \((a, b) \in 1^T.\texttt{support}\) if and only if there exists \((a', b')\) with \((a', b') = (0, 0)\) and \((-a', -b') = (a, b)\). This gives \((a, b) = (0, 0)\), which is the support of \(1\).
\(0^T = 0\).
By the definition of transpose, the image of the empty set under any function is empty.
For all polynomials \(A\), we have \((A^T)^T = A\).
By extensionality on supports. For \((a, b) \in (A^T)^T.\texttt{support}\), there exists \((a', b') \in A^T.\texttt{support}\) with \((-a', -b') = (a, b)\). And \((a', b') \in A^T.\texttt{support}\) means there exists \((a'', b'') \in A.\texttt{support}\) with \((-a'', -b'') = (a', b')\). Combining, \((-(-a''), -(-b'')) = (a, b)\), so \((a, b) = (a'', b'') \in A.\texttt{support}\). The reverse direction is similar using \((-a, -b)\).
1.19.6 Qubit and Check Labels
A qubit label is a pair \((\alpha , T)\) where \(\alpha \in \text{Fin}(\ell ) \times \text{Fin}(m)\) is a monomial index and \(T \in \{ L, R\} \) is the qubit type.
A check label is a pair \((\alpha , T)\) where \(\alpha \in \text{Fin}(\ell ) \times \text{Fin}(m)\) is a monomial index and \(T \in \{ X, Z\} \) is the check type.
1.19.7 Bivariate Bicycle Code Structure
A Bivariate Bicycle (BB) code is specified by two dimensions \(\ell , m\) and two polynomials \(A, B \in \mathbb {F}_2[x, y]\).
Physical qubits: \(n = 2\ell m\) (\(\ell m\) left qubits + \(\ell m\) right qubits)
Parity check matrices: \(H_X = [A \mid B]\), \(H_Z = [B^T \mid A^T]\)
The code is a CSS code where \(X\)-checks and \(Z\)-checks have a specific transpose relationship.
The number of physical qubits is \(n = 2\ell m\).
The number of left qubits is \(\ell m\).
The number of right qubits is \(\ell m\).
The number of \(X\)-type checks is \(\ell m\).
The number of \(Z\)-type checks is \(\ell m\).
The total number of checks is \(2\ell m\).
The qubits acted on by polynomial \(P\) at index \(\alpha \) on the left side: \(\{ (\alpha + (a,b), L) : (a,b) \in P.\texttt{support}\} \).
The qubits acted on by polynomial \(P\) at index \(\alpha \) on the right side: \(\{ (\alpha + (a,b), R) : (a,b) \in P.\texttt{support}\} \).
\(X\) check \((\alpha , X)\) acts on qubits \((\alpha A, L)\) and \((\alpha B, R)\). Returns the set of qubit labels this check acts on.
\(Z\) check \((\beta , Z)\) acts on qubits \((\beta B^T, L)\) and \((\beta A^T, R)\). Returns the set of qubit labels this check acts on.
The weight of an \(X\) check is the cardinality of its support.
The weight of a \(Z\) check is the cardinality of its support.
The row weight of polynomial \(A\) (number of nonzero entries).
The row weight of polynomial \(B\) (number of nonzero entries).
1.19.8 CSS Orthogonality
The CSS orthogonality condition for BB codes: \(H_X \cdot H_Z^T = 0\). This is equivalent to \(AB^T + BA^T = 0\) in the polynomial ring. Since we’re in \(\mathbb {F}_2\), this means \(AB^T = BA^T\).
Formally, for all \(i, j \in \text{Fin}(\ell ) \times \text{Fin}(m)\):
1.19.9 Code Construction
Construct a BB code from coefficient lists. The coefficients represent terms in the polynomial.
1.19.10 Helper Lemmas
For any BB code \(C\), \(C.\texttt{numPhysicalQubits} = 2 \cdot \ell \cdot m\).
This holds by definition (reflexivity).
For any BB code \(C\), \(C.\texttt{numLeftQubits} + C.\texttt{numRightQubits} = C.\texttt{numPhysicalQubits}\).
By simplification using the definitions, \(\ell m + \ell m = 2 \ell m\), which follows by ring arithmetic.
For any BB code \(C\), \(C.\texttt{numXChecks} = C.\texttt{numZChecks}\).
This holds by definition (reflexivity).
For any BB code \(C\), \(C.\texttt{numTotalChecks} = C.\texttt{numXChecks} + C.\texttt{numZChecks}\).
By simplification using the definitions, \(2\ell m = \ell m + \ell m\), which follows by ring arithmetic.
For any polynomial \(P\), \((P^T)^T = P\).
This follows directly from the theorem that double transpose is identity.
The zero polynomial has empty support: \(0.\texttt{support} = \emptyset \).
This holds by definition (reflexivity).
The zero polynomial has zero terms: \(0.\texttt{numTerms} = 0\).
By simplification using the definitions, \(|\emptyset | = 0\).
For any polynomial \(A\) and monomial \(\alpha \), \((A \cdot \alpha ).\texttt{numTerms} \leq A.\texttt{numTerms}\).
By simplification using the definitions, the result follows from the fact that the cardinality of an image is at most the cardinality of the original set.
For any index \(\alpha \), \(\texttt{leftQubitsActedBy}(0, \alpha ) = \emptyset \).
By simplification, the image of the empty set is empty.
For any index \(\alpha \), \(\texttt{rightQubitsActedBy}(0, \alpha ) = \emptyset \).
By simplification, the image of the empty set is empty.
An \(X\) check on a code with zero \(A\) and \(B\) polynomials has empty support.
By simplification using the facts that left and right qubits acted by zero polynomial is empty, and \(\emptyset \cup \emptyset = \emptyset \).
For all polynomials \(A, B, C\), we have \((A + B) + C = A + (B + C)\).
By simplification using the definition of addition, the result follows from the associativity of symmetric difference.
\(|\text{BBQubitLabel}(\ell , m)| = 2 \cdot \ell \cdot m\).
We first establish that \(|\text{BBQubitLabel}(\ell , m)| = |(\text{Fin}(\ell ) \times \text{Fin}(m)) \times \text{QubitType}|\) by the equivalence defining the Fintype instance. Then by cardinality of products, this equals \(|\text{Fin}(\ell )| \cdot |\text{Fin}(m)| \cdot |\text{QubitType}| = \ell \cdot m \cdot 2 = 2 \ell m\).
\(|\text{BBCheckLabel}(\ell , m)| = 2 \cdot \ell \cdot m\).
We first establish that \(|\text{BBCheckLabel}(\ell , m)| = |(\text{Fin}(\ell ) \times \text{Fin}(m)) \times \text{BBCheckType}|\) by the equivalence defining the Fintype instance. Then by cardinality of products, this equals \(|\text{Fin}(\ell )| \cdot |\text{Fin}(m)| \cdot |\text{BBCheckType}| = \ell \cdot m \cdot 2 = 2 \ell m\).
The parameter \(\ell \) for the Gross code is \(\ell = 12\).
The parameter \(m\) for the Gross code is \(m = 6\).
The total number of physical qubits in the Gross code is \(2 \cdot \ell \cdot m = 2 \cdot 12 \cdot 6 = 144\).
By computation: \(2 \times 12 \times 6 = 144\).
We have \(12 \times 12 = 144\). The name “gross” comes from \(12\) dozen \(= 144\).
By computation: \(12 \times 12 = 144\).
The polynomial \(A\) for the Gross code is
with support \(\{ (3, 0), (0, 2), (0, 1)\} \).
The polynomial \(B\) for the Gross code is
with support \(\{ (0, 3), (2, 0), (1, 0)\} \).
The polynomial \(A\) has exactly \(3\) terms.
By simplification of the definition and computation: the support \(\{ (3, 0), (0, 2), (0, 1)\} \) has cardinality \(3\).
The polynomial \(B\) has exactly \(3\) terms.
By simplification of the definition and computation: the support \(\{ (0, 3), (2, 0), (1, 0)\} \) has cardinality \(3\).
The Gross code is the \([[144, 12, 12]]\) Bivariate Bicycle code defined by:
\(\ell = 12\), \(m = 6\)
\(A = x^3 + y^2 + y\)
\(B = y^3 + x^2 + x\)
The Gross code parameters are \([[n, k, d]] = [[144, 12, 12]]\):
Number of physical qubits: \(n = 144\)
Number of logical qubits: \(k = 12\)
Code distance: \(d = 12\)
The canonical instance of Gross code parameters with \(n = 144\), \(k = 12\), \(d = 12\).
The Gross code has \(144\) physical qubits.
By simplification of the definition of the number of physical qubits for bivariate bicycle codes and computation.
The Gross code has \(72\) left qubits and \(72\) right qubits.
By simplification of the definitions and computation: \(\ell \cdot m = 12 \cdot 6 = 72\) for each side.
The polynomial \(f\) for logical \(X\) operators is
with support:
Constant and \(x\) terms: \((0,0), (1,0), (2,0), (3,0), (6,0), (7,0), (8,0), (9,0)\)
\(y^3\) terms: \((1,3), (5,3), (7,3), (11,3)\)
Total: \(12\) terms.
The polynomial \(f\) has exactly \(12\) terms.
By simplification of the definition and computation of the cardinality of the support set.
The polynomial \(g\) for the second logical \(X\) operator basis is
with support \(\{ (1, 0), (2, 1), (0, 2), (1, 2), (2, 3), (0, 4)\} \).
The polynomial \(h\) for the second logical \(X\) operator basis is
with support \(\{ (0, 0), (0, 1), (1, 1), (0, 2), (0, 3), (1, 3)\} \).
The polynomial \(g\) has exactly \(6\) terms.
By simplification of the definition and computation.
The polynomial \(h\) has exactly \(6\) terms.
By simplification of the definition and computation.
The transpose of \(f\): \(f^T = f(x^{-1}, y^{-1})\) for logical \(Z\) operators. Under \(x \to x^{-1} = x^{11}\), \(y \to y^{-1} = y^{5}\):
\((0,0) \to (0,0)\)
\((a,b) \to (12-a \mod 12, 6-b \mod 6)\)
The transpose of \(g\) for logical \(Z\) operators.
The transpose of \(h\) for logical \(Z\) operators.
The polynomial \(f^T\) has at most \(12\) terms: \(|f^T| \le 12\).
By simplification of the transpose definition, the number of terms is at most the cardinality of the image of the support under the transpose map, which is at most the cardinality of the original support by the fact that the image of a finite set under any map has cardinality at most that of the original set.
A logical \(X\) operator of the first kind: \(\bar{X}_\alpha = X(\alpha f, 0)\) where \(\alpha \in \mathbb {Z}_\ell \times \mathbb {Z}_m\) is a monomial coefficient. This operator acts on left qubits at positions \(\alpha f\) with no action on right qubits.
The support of the logical \(X\) operator \(\bar{X}_\alpha \) on left qubits is the set of positions \(\alpha f\), computed by shifting the support of \(f\) by \(\alpha \).
The support of \(\bar{X}_\alpha \) on right qubits is empty: \(\bar{X}_\alpha \) has no support on right qubits.
The total weight of \(\bar{X}_\alpha \) is at most \(12\).
By simplification, the left support is the image of the support of \(f\) under translation by \(\alpha \). The cardinality of this image is at most the cardinality of the support of \(f\), which equals \(12\) by the weight theorem for \(f\).
A logical \(X\) operator of the second kind: \(\bar{X}'_\beta = X(\beta g, \beta h)\) where \(\beta \in \mathbb {Z}_\ell \times \mathbb {Z}_m\) is a monomial coefficient. This operator acts on left qubits at positions \(\beta g\) and right qubits at positions \(\beta h\).
The support of the logical \(X\) operator \(\bar{X}'_\beta \) on left qubits is the set of positions \(\beta g\).
The support of the logical \(X\) operator \(\bar{X}'_\beta \) on right qubits is the set of positions \(\beta h\).
A logical \(Z\) operator of the first kind: \(\bar{Z}_\beta = Z(\beta h^T, \beta g^T)\). This uses the transpose symmetry of the BB code.
A logical \(Z\) operator of the second kind: \(\bar{Z}'_\alpha = Z(0, \alpha f^T)\). This operator has no action on left qubits and acts on right qubits at positions \(\alpha f^T\).
The support of \(\bar{Z}'_\alpha \) on left qubits is empty.
The support of \(\bar{Z}'_\alpha \) on right qubits is the set of positions \(\alpha f^T\).
The Gross code distance is \(d = 12\) (by construction, the weight of the logical operators).
The number of logical qubits in the Gross code is \(k = 12\).
The dimension of the code space is \(2^{12} = 4096\).
By simplification: \(2^{12} = 4096\).
The name “gross” comes from \(12\) dozen: \(12 \times 12 = \ell \times \ell = 144\).
This holds by reflexivity.
Each \(X\)-check has weight at most \(6\): \(|A| + |B| = 3 + 3 = 6\).
Rewriting using the theorems that \(|A| = 3\) and \(|B| = 3\), we get \(3 + 3 = 6\).
Each \(Z\)-check also has weight at most \(6\) (by transpose symmetry): \(|A^T| + |B^T| \le 6\).
We first establish that \(|A^T| \le 3\): by the definition of transpose, the support of \(A^T\) is the image of the support of \(A\) under the negation map \((a, b) \mapsto (-a, -b)\). The cardinality of this image is at most the cardinality of the original support, which equals \(3\).
Similarly, \(|B^T| \le 3\): the support of \(B^T\) is the image of the support of \(B\) under negation, with cardinality at most \(3\).
By integer arithmetic, \(|A^T| + |B^T| \le 3 + 3 = 6\).
The Gross code uses \(\ell = 12\).
This holds by reflexivity.
The Gross code uses \(m = 6\).
This holds by reflexivity.
We have \(\ell \cdot m = 12 \cdot 6 = 72\).
By computation.
The polynomial \(A\) of the Gross code equals \(x^3 + y^2 + y\).
This holds by reflexivity from the definition.
The polynomial \(B\) of the Gross code equals \(y^3 + x^2 + x\).
This holds by reflexivity from the definition.
The polynomials \(A\) and \(B\) have the same number of terms: \(|A| = |B| = 3\).
Rewriting using both theorems gives \(3 = 3\).
The monomial group \(M = \mathbb {Z}_\ell \times \mathbb {Z}_m\) has order \(|M| = 12 \times 6 = 72\).
By simplification of the cardinality of the product of finite types and computation.
There are \(72\) \(X\)-checks and \(72\) \(Z\)-checks, totaling \(144\) checks.
By simplification of the definition of total number of checks for bivariate bicycle codes and computation.
The Gross code is symmetric: \(A\) and \(B\) have the same structure up to \(x \leftrightarrow y\) exchange. In particular, \(|A.\mathrm{support}| = |B.\mathrm{support}|\).
By simplification of the definitions and computation.
The Gross code has rate \(k/n = 12/144 = 1/12\).
By unfolding the definition of the canonical parameters and numerical normalization: \(12/144 = 1/12\).
The Gross code is a member of the BB code family, constructed from polynomials \(A\) and \(B\).
This holds by reflexivity from the definition.
The support of polynomial \(A\) contains the monomial \(x^3\), i.e., \((3, 0) \in A.\mathrm{support}\).
By simplification of the definition and computation.
The support of polynomial \(A\) contains the monomial \(y^2\), i.e., \((0, 2) \in A.\mathrm{support}\).
By simplification of the definition and computation.
The support of polynomial \(A\) contains the monomial \(y\), i.e., \((0, 1) \in A.\mathrm{support}\).
By simplification of the definition and computation.
The support of polynomial \(B\) contains the monomial \(y^3\), i.e., \((0, 3) \in B.\mathrm{support}\).
By simplification of the definition and computation.
The support of polynomial \(B\) contains the monomial \(x^2\), i.e., \((2, 0) \in B.\mathrm{support}\).
By simplification of the definition and computation.
The support of polynomial \(B\) contains the monomial \(x\), i.e., \((1, 0) \in B.\mathrm{support}\).
By simplification of the definition and computation.
The \(\ell \) parameter for the Double Gross code is \(\ell = 12\).
The \(m\) parameter for the Double Gross code is \(m = 12\).
The total number of physical qubits in the Double Gross code is:
This is verified by computation.
The number 288 equals \(2 \times 144\), i.e., “double gross”:
This is verified by computation.
The polynomial \(A\) for the Double Gross code is:
The support is \(\{ (3, 0), (0, 7), (0, 2)\} \).
The polynomial \(B\) for the Double Gross code is:
The support is \(\{ (0, 3), (2, 0), (1, 0)\} \).
The polynomial \(A\) has 3 terms:
By simplification using the definition of \(A\) and the number of terms function, this is verified by computation.
The polynomial \(B\) has 3 terms:
By simplification using the definition of \(B\) and the number of terms function, this is verified by computation.
The Double Gross code is a \([[288, 12, 18]]\) Bivariate Bicycle code defined by:
Parameters: \(\ell = 12\), \(m = 12\)
Polynomial \(A = x^3 + y^7 + y^2\)
Polynomial \(B = y^3 + x^2 + x\)
The Double Gross code parameters are \([[n, k, d]] = [[288, 12, 18]]\):
Number of physical qubits: \(n = 288\)
Number of logical qubits: \(k = 12\)
Code distance: \(d = 18\)
The canonical Double Gross code parameters instance with \(n = 288\), \(k = 12\), and \(d = 18\).
The Double Gross code has 288 physical qubits:
By simplification using the definition of the number of physical qubits for Bivariate Bicycle codes, this is verified by computation.
The Double Gross code has 144 left qubits and 144 right qubits:
By simplification using the definitions of left and right qubit counts, we verify both conditions by computation.
The polynomial \(f\) for logical \(X\) operators with 18 terms:
Pure \(x\) terms (\(y^0\)): 8 terms at \((0,0), (1,0), (2,0), (7,0), (8,0), (9,0), (10,0), (11,0)\)
\(y^3\) terms: 4 terms at \((0,3), (6,3), (8,3), (10,3)\)
\(y^6\) terms: 4 terms at \((5,6), (6,6), (9,6), (10,6)\)
\(y^9\) terms: 2 terms at \((4,9), (8,9)\)
The explicit support of the logical \(X\) polynomial \(f\):
The polynomial \(f\) has weight 18:
By simplification using the definition of \(f\) and the number of terms function, this is verified by computation.
A logical \(X\) operator for the Double Gross code: \(\bar{X}_\alpha = X(\alpha f, 0)\), which acts on left qubits at positions \(\alpha f\) and has no action on right qubits.
The support of the logical \(X\) operator \(\bar{X}_\alpha \) on left qubits is:
The logical \(X\) operator \(\bar{X}_\alpha \) has no support on right qubits:
The total weight of \(\bar{X}_\alpha \) is at most 18:
By simplification using the definition of left support, we compute that the cardinality of the image of the support under translation is at most the cardinality of the support (by the card_image_le lemma), which equals 18 by the weight theorem for \(f\).
The transpose of \(f\) for logical \(Z\) operators: \(f^T = f(x^{-1}, y^{-1})\).
The polynomial \(f^T\) has at most 18 terms:
Unfolding the definition of \(f^T\) and the transpose operation, the cardinality of the image under the transpose map is at most the cardinality of the original support (by card_image_le), which equals 18.
A logical \(Z\) operator for the Double Gross code: \(\bar{Z}'_\alpha = Z(0, \alpha f^T)\), which has no action on left qubits and acts on right qubits at positions \(\alpha f^T\).
The logical \(Z\) operator \(\bar{Z}'_\alpha \) has no support on left qubits:
The support of \(\bar{Z}'_\alpha \) on right qubits is:
The Double Gross code distance is \(d = 18\).
The number of logical qubits in the Double Gross code is \(k = 12\).
The dimension of the code space is \(2^{12} = 4096\):
By simplification using the definition of the number of logical qubits, this is verified by computation.
The name “double gross” comes from:
This holds by reflexivity.
Each \(X\)-check has weight at most 6:
Rewriting using the weight theorems for \(A\) and \(B\), the result follows.
Each \(Z\)-check has weight at most 6 (by transpose symmetry):
We first establish that \(|A^T| \leq 3\): by simplification using the transpose and numTerms definitions, the cardinality of the image under the transpose map is at most the cardinality of \(A\)’s support by card_image_le, which equals 3. Similarly, \(|B^T| \leq 3\) by the same reasoning. By integer arithmetic (omega), \(|A^T| + |B^T| \leq 6\).
The Double Gross code uses \(\ell = 12\).
This holds by reflexivity.
The Double Gross code uses \(m = 12\).
This holds by reflexivity.
The product \(\ell \times m = 144\):
This is verified by computation.
The polynomial \(A\) of the Double Gross code equals \(\texttt{doubleGrossPolyA}\).
This holds by reflexivity.
The polynomial \(B\) of the Double Gross code equals \(\texttt{doubleGrossPolyB}\).
This holds by reflexivity.
The polynomials \(A\) and \(B\) have the same number of terms:
Rewriting using the weight theorems for \(A\) and \(B\), both equal 3.
The monomial group \(M = \mathbb {Z}_\ell \times \mathbb {Z}_m\) has order 144:
By simplification using the cardinality of product types and finite types, this is verified by computation.
There are 144 \(X\)-checks and 144 \(Z\)-checks, totaling 288 checks.
By simplification using the definition of total checks for Bivariate Bicycle codes, this is verified by computation.
The Double Gross code is a member of the BB code family with polynomials \(A\) and \(B\).
This holds by reflexivity.
The support of polynomial \(A\) contains \(x^3\):
By simplification using the definition of \(A\), this is verified by computation.
The support of polynomial \(A\) contains \(y^7\):
By simplification using the definition of \(A\), this is verified by computation.
The support of polynomial \(A\) contains \(y^2\):
By simplification using the definition of \(A\), this is verified by computation.
The support of polynomial \(B\) contains \(y^3\):
By simplification using the definition of \(B\), this is verified by computation.
The support of polynomial \(B\) contains \(x^2\):
By simplification using the definition of \(B\), this is verified by computation.
The support of polynomial \(B\) contains \(x\):
By simplification using the definition of \(B\), this is verified by computation.
The Double Gross code has rate \(k/n = 12/288 = 1/24\):
Unfolding the definition of the canonical parameters, the result follows by numerical computation.
The Double Gross code has twice the qubits per side as the Gross code:
This holds by reflexivity.
The polynomial \(f\) contains the identity term:
By simplification using the definition of \(f\), this is verified by computation.
The polynomial \(f\) contains the \(x\) term:
By simplification using the definition of \(f\), this is verified by computation.
The polynomial \(f\) contains the \(x^2\) term:
By simplification using the definition of \(f\), this is verified by computation.
The logical \(X\) operator weight equals the code distance:
Rewriting using the weight theorem for \(f\) and the definition of distance, both equal 18.
The vertex type for the Gross code gauging graph is \(\text{Fin}\, 12\). Each vertex corresponds to a monomial in the logical operator support \(f\).
The mapping from \(\text{Fin}\, 12\) to the actual monomial exponents \((a, b)\) in \(f\). The logical polynomial \(f\) has support:
The mapping is defined as:
The monomial mapping is injective.
Let \(a, b \in \text{Fin}\, 12\) and suppose \(\text{grossVertexToMonomial}(a) = \text{grossVertexToMonomial}(b)\). By case analysis on all \(12 \times 12 = 144\) pairs of vertices, we verify that if the monomial exponents are equal, then \(a = b\). For pairs where \(a \neq b\), the monomial exponents differ (checking via the explicit definition and properties of \(\text{Fin}\)), so \(a = b\).
The vertices correspond exactly to the support of \(\text{logicalXPolyF}\). For all \(v \in \text{Fin}\, 12\):
By case analysis on all 12 vertices \(v \in \text{Fin}\, 12\), we verify computationally that each monomial exponent pair is in the support of the logical polynomial \(f\).
The support of \(B^T\) (transpose of \(\text{grossPolyB}\)) is:
The support of \(B^T\) is \(\{ (0, 3), (10, 0), (11, 0)\} \).
This is verified by computational evaluation of the transpose operation and support extraction.
The 18 matching edges of the Gross code gauging graph connect pairs of vertices that participate in the same \(Z\) check:
The number of matching edges is 18.
This is verified by computational evaluation of the cardinality of the explicit finite set.
The 4 expansion edges added for sufficient expansion:
These correspond to the monomial pairs \((x^2, x^5y^3)\), \((x^2, x^6)\), \((x^5y^3, x^{11}y^3)\), and \((x^7y^3, x^{11}y^3)\).
Note: The paper verified these edges preserve distance 12 via BP+OSD decoder and integer programming. The distance preservation is not formally proven here.
The number of expansion edges is 4.
This is verified by computational evaluation of the cardinality of the explicit finite set.
All edges of the gauging graph: \(\text{grossMatchingEdges} \cup \text{grossExpansionEdges}\).
The matching edges and expansion edges are disjoint: \(\text{Disjoint}(\text{grossMatchingEdges}, \text{grossExpansionEdges})\).
We rewrite using the definition that two finite sets are disjoint iff their intersection is empty. This is verified computationally by checking that no element appears in both sets.
The total number of edges is \(18 + 4 = 22\).
By the disjointness of matching and expansion edges, the cardinality of the union equals the sum of cardinalities. Rewriting with the cardinalities of matching (18) and expansion (4) edges yields 22.
The adjacency relation for the Gross code gauging graph: \(v\) and \(w\) are adjacent iff \(v \neq w\) and either \((v, w) \in \text{grossAllEdges}\) or \((w, v) \in \text{grossAllEdges}\).
The gauging graph as a SimpleGraph on \(\text{Fin}\, 12\), with adjacency given by \(\text{grossGaugingAdj}\).
The neighbors of a vertex \(v\) are those \(w\) such that \(\text{grossGaugingSimpleGraph.Adj}(v, w)\).
The degree of a vertex \(v\) is the cardinality of its neighbor set.
The maximum vertex degree in the graph: \(\sup _{v \in \text{Fin}\, 12} \text{grossVertexDegree}(v)\).
The maximum degree is at most 6.
This is verified by computational evaluation of the supremum over all vertices.
Every vertex has degree at most 6: for all \(v \in \text{Fin}\, 12\), \(\text{grossVertexDegree}(v) \leq 6\).
By case analysis on all 12 vertices, we verify computationally that each has degree at most 6.
A cycle is represented as a list of vertices in \(\text{Fin}\, 12\).
A list of vertices forms a valid cycle if all consecutive pairs (including the last-to-first) are adjacent in the graph.
The 7 cycles for the flux operators \(B_p\):
\([1, 2, 3]\) — Triangle with unique edge \(1\)-\(3\)
\([3, 4, 2]\) — Triangle with unique edge \(3\)-\(4\)
\([4, 5, 6]\) — Triangle with unique edge \(4\)-\(5\)
\([5, 6, 7]\) — Triangle with unique edge \(5\)-\(7\)
\([0, 6, 7, 1]\) — Quadrilateral with unique edge \(0\)-\(6\)
\([8, 9, 10]\) — Triangle with unique edge \(8\)-\(10\)
\([2, 9, 11, 10, 3]\) — Pentagon via expansion with unique edge \(9\)-\(11\)
There are exactly 7 flux cycles: \(|\text{grossFluxCycles}| = 7\).
This holds by reflexivity from the explicit definition.
Each cycle in \(\text{grossFluxCycles}\) is a valid cycle in the graph.
This is verified by computational evaluation of the cycle validity predicate for each of the 7 cycles.
A predicate checking if an edge \((v, w)\) appears in a cycle (in either direction).
The unique edges for each of the 7 cycles:
Checks that the unique edge for cycle \(i\) is actually contained in cycle \(i\).
Checks that the unique edge for cycle \(i\) does not appear in any other cycle \(j \neq i\).
For each \(i \in \text{Fin}\, 7\), the unique edge is in its cycle and not in any other cycle.
This is verified by computational evaluation for all 7 cycles.
For each \(i \in \text{Fin}\, 7\), \(\text{uniqueEdgeInItsCycle}(i)\) and \(\text{uniqueEdgeNotInOtherCycles}(i)\) both hold.
This follows directly from the computational verification in each_cycle_has_unique_edge.
Convert a cycle to its edge indicator vector over \(\mathbb {Z}/2\mathbb {Z}\). The vector has entry 1 at position \(i\) if the unique edge for cycle \(i\) is in the given cycle.
The edge vectors for the 7 flux cycles: \(i \mapsto \text{cycleToEdgeVector}(\text{grossFluxCycles}[i])\).
Each cycle vector has a 1 at its own unique edge position: \(\text{grossFluxCycleVectors}(i)(i) = 1\).
By the definition of \(\text{grossFluxCycleVectors}\) and \(\text{cycleToEdgeVector}\), we use the unique edge criterion to show that the unique edge for cycle \(i\) is in cycle \(i\), so the indicator is 1.
Each cycle vector has a 0 at other cycles’ unique edge positions: for \(i \neq j\), \(\text{grossFluxCycleVectors}(i)(j) = 0\).
By case analysis on all 42 off-diagonal pairs \((i, j)\) with \(i \neq j\), we verify computationally that the indicator is 0.
The 7 cycle vectors are linearly independent over \(\mathbb {Z}/2\mathbb {Z}\).
We use Mathlib’s characterization of finite linear independence. Let \(g : \text{Fin}\, 7 \to \mathbb {Z}/2\mathbb {Z}\) and suppose \(\sum _{i} g_i \cdot \text{grossFluxCycleVectors}(i) = 0\). We must show \(g_j = 0\) for all \(j\).
Evaluating at coordinate \(j\), we have:
By the diagonal property, \(\text{grossFluxCycleVectors}(j)(j) = 1\). By the off-diagonal property, for \(i \neq j\), \(\text{grossFluxCycleVectors}(i)(j) = 0\). Thus the sum reduces to \(g_j \cdot 1 + \sum _{i \neq j} g_i \cdot 0 = g_j = 0\).
The number of vertices in the gauging graph: 12.
The number of edges in the gauging graph: 22.
The cycle rank formula for a connected graph: \(|E| - |V| + 1\).
The cycle rank equals 11: \(22 - 12 + 1 = 11\).
By expanding the definitions and numerical computation: \(22 - 12 + 1 = 11\).
The number of independent \(B_p\) checks we construct: 7.
The 7 independent cycles we found match the claimed count.
This holds by reflexivity.
Summary of what is proven about cycles:
There exist 7 linearly independent cycles in the graph
The cycle space has dimension 11
Each cycle is a valid path in the graph
This follows directly from the previous theorems: the length is 7 by definition, linear independence is proven, and validity is verified computationally.
Number of new \(X\) checks (Gauss law operators \(A_v\)): one per vertex = 12.
Number of new \(Z\) checks (flux operators \(B_p\)): one per independent cycle = 7.
Number of new qubits (edge qubits): one per edge = 22.
Total overhead: \(\text{grossNewXChecks} + \text{grossNewZChecks} + \text{grossNewQubits}\).
Total overhead equals 41: \(12 + 7 + 22 = 41\).
By expanding definitions and numerical computation.
Maximum Gauss law weight: max degree \(+ 1\) for the vertex qubit.
Gauss law weight \(\leq 7\).
Since the max degree is at most 6, the max Gauss law weight is at most \(6 + 1 = 7\).
Maximum flux check weight: the longest flux cycle has length 5.
All flux cycles have length \(\leq 5\).
This is verified computationally by checking the length of each of the 7 cycles.
Flux check weight \(\leq 7\).
Since \(\text{grossMaxFluxWeight} = 5 \leq 7\).
All checks have weight \(\leq 7\).
This follows from the bounds on Gauss law weight and flux weight.
All qubit degrees \(\leq 7\): for all \(v \in \text{Fin}\, 12\), \(\text{grossVertexDegree}(v) \leq 7\).
Since every vertex has degree at most 6, which is at most 7.
The original Gross code distance: 12.
The claimed deformed code distance: 12.
Note: This was verified using BP+OSD decoder and integer programming in the paper. This is a documented claim, not a proven theorem.
The original and deformed code distances are both claimed to be 12.
By reflexivity from the definitions.
The main theorem: the Gross code gauging graph exists with all stated properties:
12 vertices corresponding to monomials in \(f\) (with injective mapping)
18 matching edges + 4 expansion edges = 22 total edges, disjoint sets
Cycle rank = 11, with 7 \(\mathrm{GF}(2)\)-independent flux cycles
Total overhead = \(12 + 7 + 22 = 41\)
Max check weight \(\leq 7\), max qubit degree \(\leq 7\)
The cardinality of \(\text{GrossGaugingVertex}\) is 12 by decidable computation. Injectivity of the vertex-to-monomial mapping is proven. The edge cardinalities (18 matching, 4 expansion, 22 total) and disjointness are verified computationally. The cycle rank equals 11 by arithmetic. The length of the flux cycles list is 7 by definition. Linear independence is proven via the unique edge criterion. Total overhead equals 41 by arithmetic. The weight bounds follow from the degree bounds and cycle length bounds.
Expansion edge \((x^2, x^5y^3)\) corresponds to vertices \((2, 9)\):
Membership is verified computationally; the monomial values follow by reflexivity.
Expansion edge \((x^2, x^6)\) corresponds to vertices \((2, 4)\):
Membership is verified computationally; the monomial values follow by reflexivity.
Expansion edge \((x^5y^3, x^{11}y^3)\) corresponds to vertices \((9, 11)\):
Membership is verified computationally; the monomial values follow by reflexivity.
Expansion edge \((x^7y^3, x^{11}y^3)\) corresponds to vertices \((10, 11)\):
Membership is verified computationally; the monomial values follow by reflexivity.
The number of vertices equals the number of terms in \(f\): \(\text{grossNumVertices} = \text{logicalXPolyF.numTerms}\).
Rewriting with the fact that \(\text{logicalXPolyF}\) has weight 12, this follows by reflexivity.
The logical operator has weight 12: \(\text{logicalXPolyF.numTerms} = 12\).
This is the statement of \(\text{logicalXPolyF\_ weight}\).
The graph has 12 vertices: \(|\text{GrossGaugingVertex}| = 12\).
By decidable computation.
The Gross code parameters are \([[144, 12, 12]]\):
By simplification using the definition of \(\text{grossCodeParams}\).
Summary of the gauging graph parameters:
The first two equalities hold by definition; the remaining follow from the respective theorems.
1.20 Double Gross Code Gauging Construction (Proposition 2)
This section formalizes the gauging construction for the Double Gross code \([[288, 12, 18]]\). The proposition establishes the existence of a gauging graph \(G\) to measure \(\bar{X}_\alpha \) with specific structural properties.
The vertex type for the Double Gross code gauging graph is \(\text{Fin}\, 18\). Each vertex corresponds to a monomial in the logical operator support \(f\).
The mapping \(\varphi : \text{Fin}\, 18 \to \text{Fin}\, \ell \times \text{Fin}\, m\) from vertices to monomial exponents \((a, b)\) in \(f\) is defined as:
Vertex 0: \((0, 0) = 1\)
Vertex 1: \((1, 0) = x\)
Vertex 2: \((2, 0) = x^2\)
Vertex 3: \((7, 0) = x^7\)
Vertex 4: \((8, 0) = x^8\)
Vertex 5: \((9, 0) = x^9\)
Vertex 6: \((10, 0) = x^{10}\)
Vertex 7: \((11, 0) = x^{11}\)
Vertex 8: \((0, 3) = y^3\)
Vertex 9: \((6, 3) = x^6y^3\)
Vertex 10: \((8, 3) = x^8y^3\)
Vertex 11: \((10, 3) = x^{10}y^3\)
Vertex 12: \((5, 6) = x^5y^6\)
Vertex 13: \((6, 6) = x^6y^6\)
Vertex 14: \((9, 6) = x^9y^6\)
Vertex 15: \((10, 6) = x^{10}y^6\)
Vertex 16: \((4, 9) = x^4y^9\)
Vertex 17: \((8, 9) = x^8y^9\)
The monomial mapping \(\varphi \) is injective.
Let \(a, b \in \text{Fin}\, 18\) and assume \(\varphi (a) = \varphi (b)\). We verify by case analysis on all 18 possible values of \(a\) and all 18 possible values of \(b\) that this implies \(a = b\). The verification proceeds by simplification using the definition of \(\varphi \).
For all \(v \in \text{Fin}\, 18\), we have \(\varphi (v) \in \text{support}(f)\) where \(f\) is the polynomial defining the logical \(\bar{X}_\alpha \) operator.
We verify by case analysis on all 18 vertices that each monomial image lies in the support of \(f\). This is verified by native computation.
The 6 distinct expansion edges from the original statement are:
corresponding to the monomial pairs:
\((x^4y^9, x^9y^6)\): vertices 16 and 14
\((y^3, x^{11})\): vertices 8 and 7
\((x^7, x^{10}y^6)\): vertices 3 and 15
\((x^8y^3, x^{10}y^6)\): vertices 10 and 15
\((1, x^8)\): vertices 0 and 4
\((x^2, x^6y^3)\): vertices 2 and 9 (appears twice as a multi-edge in the full construction)
The pair \((16, 14)\) is in the expansion edge set, with \(\varphi (16) = (4, 9)\) and \(\varphi (14) = (9, 6)\).
Membership is verified by native computation, and the monomial values follow by reflexivity from the definition of \(\varphi \).
The pair \((8, 7)\) is in the expansion edge set, with \(\varphi (8) = (0, 3)\) and \(\varphi (7) = (11, 0)\).
Membership is verified by native computation, and the monomial values follow by reflexivity from the definition of \(\varphi \).
The pair \((3, 15)\) is in the expansion edge set, with \(\varphi (3) = (7, 0)\) and \(\varphi (15) = (10, 6)\).
Membership is verified by native computation, and the monomial values follow by reflexivity from the definition of \(\varphi \).
The pair \((10, 15)\) is in the expansion edge set, with \(\varphi (10) = (8, 3)\) and \(\varphi (15) = (10, 6)\).
Membership is verified by native computation, and the monomial values follow by reflexivity from the definition of \(\varphi \).
The pair \((0, 4)\) is in the expansion edge set, with \(\varphi (0) = (0, 0)\) and \(\varphi (4) = (8, 0)\).
Membership is verified by native computation, and the monomial values follow by reflexivity from the definition of \(\varphi \).
The pair \((2, 9)\) is in the expansion edge set, with \(\varphi (2) = (2, 0)\) and \(\varphi (9) = (6, 3)\). This edge appears twice as a multi-edge in the full construction.
Membership is verified by native computation, and the monomial values follow by reflexivity from the definition of \(\varphi \).
The number of distinct expansion edges in the simple graph model is \(|\text{ExpansionEdges}| = 6\).
This is verified by native computation.
The 27 matching edges connecting vertices in the same \(Z\) check:
The number of matching edges is \(|\text{MatchingEdges}| = 27\).
This is verified by native computation.
All edges of the simple gauging graph:
The matching edges and expansion edges are disjoint:
We verify that the intersection is empty by native computation.
The total number of simple edges is \(27 + 6 = 33\).
By the disjointness of the matching and expansion edges, we have:
The adjacency relation for the Double Gross code gauging graph is defined as:
The gauging graph as a SimpleGraph on \(\text{Fin}\, 18\) with adjacency relation \(\text{Adj}\). The graph is symmetric (by the symmetric definition of adjacency) and loopless (since \(v \neq w\) is required).
For a vertex \(v\), the set of neighbors is:
The degree of a vertex \(v\) is \(\deg (v) = |N(v)|\).
The maximum vertex degree in the graph:
The maximum degree satisfies \(\Delta \leq 6\).
This is verified by native computation.
For all \(v \in \text{Fin}\, 18\), we have \(\deg (v) \leq 6\).
We verify by case analysis on all 18 vertices that each degree is at most 6, using native computation.
The number of independent cycles claimed in the original statement: \(13\).
The number of vertices in the gauging graph: \(18\).
The number of edges in the simple graph (without multi-edge): \(33\).
The number of edges in the full multigraph (with multi-edge \((x^2, x^6y^3)\) counted twice): \(34\).
The cycle rank for the simple graph:
The simple graph cycle rank equals 16.
By the definitions and numerical computation: \(33 - 18 + 1 = 16\).
The cycle rank for the full multigraph:
The full multigraph cycle rank equals 17.
By the definitions and numerical computation: \(34 - 18 + 1 = 17\).
The multi-edge contributes exactly 1 to the cycle rank:
Rewriting using the cycle rank values: \(17 - 16 = 1\).
The following are proven:
The cycle space of the multigraph has dimension 17
\(13 \leq 17\): The claimed 13 independent cycles fit within the cycle space
The first claim follows from \(\text{CycleRank}_{\text{full}} = 17\). For the second, we verify numerically that \(13 \leq 17\).
The number of new \(X\) checks (Gauss law operators \(A_v\)) equals the number of vertices: \(18\).
The number of new \(Z\) checks (Flux operators \(B_p\)) equals the number of independent cycles: \(13\).
The number of new qubits (edge qubits in the full multigraph) equals the number of edges: \(34\).
The total overhead:
The total overhead equals 65.
By the definitions and numerical computation: \(18 + 13 + 34 = 65\).
The number of new \(Z\) checks is at most the cycle rank: \(13 \leq 17\).
Rewriting using the cycle rank value, this reduces to verifying \(13 \leq 17\) by numerical computation.
The maximum Gauss law weight: \(\Delta + 1\) where \(\Delta \) is the maximum degree.
The Gauss law weight is at most 7.
Since \(\Delta \leq 6\), we have \(\Delta + 1 \leq 7\).
The maximum flux check weight (the longest flux cycle has length 6): \(6\).
The flux check weight is at most 7.
By definition, \(6 \leq 7\).
The flux cycles have bounded weight: the maximum is at most 7.
By definition, \(6 \leq 7\).
All checks have weight at most 7: both Gauss law and flux checks.
This follows from combining the bounds on Gauss law weight and flux weight.
For all \(v \in \text{Fin}\, 18\), the vertex degree (and hence qubit degree) satisfies \(\deg (v) \leq 7\).
Since all vertex degrees are at most 6, they are certainly at most 7.
The Double Gross code gauging graph exists with all stated properties:
18 vertices corresponding to monomials in \(f\) (with injective mapping)
27 matching edges
6 distinct expansion edges (the 7th edge \((x^2, x^6y^3)\) twice is a multi-edge)
Cycle rank 17 for multigraph, 13 independent cycles fit within
Total overhead = \(18 + 13 + 34 = 65\)
Max check weight \(\leq 7\), max qubit degree \(\leq 7\)
The cardinality of the vertex type is 18 by decidable computation. The injectivity of the vertex-to-monomial mapping is established in Theorem 2091. The matching edges cardinality (27), expansion edges cardinality (6), disjointness, and total simple edges (33) follow from the respective theorems. The cycle ranks for simple (16) and full (17) graphs are computed. The bound \(13 \leq 17\) is verified numerically. The overhead equals 65 by arithmetic. The Gauss law weight bound and flux weight bound are both at most 7. Finally, all qubit degrees are at most 7 by Theorem 2135.
The number of vertices equals the number of terms in \(f\):
By rewriting using the weight of \(f\) and reflexivity.
The graph has 18 vertices: \(|\text{Fin}\, 18| = 18\).
This is verified by decidable computation.
The Double Gross code parameters are \([[288, 12, 18]]\):
By simplification using the definition of the code parameters.
Summary of the gauging graph parameters:
Number of vertices: 18
Number of edges (full): 34
Cycle rank (full): 17
Independent BP checks: 13
Total overhead: 65
By reflexivity for the direct definitions and applying the relevant theorems for cycle rank and total overhead.
The number of edges in the explicit edge set matches the simple graph count:
By rewriting using the all edges simple cardinality theorem.
The number of vertices in \(\text{Fin}\, 18\) matches the expected count:
By simplification using the definition.
[Relation to Lattice Surgery]
The gauging measurement generalizes surface code lattice surgery:
Surface code recovery: Consider logical operators \(\bar{X}_1 \otimes \bar{X}_2\) on the right and left edges of two adjacent surface code patches. Choosing the gauging graph \(G\) as a ladder joining the edge qubits results in:
The deformed code is a single larger surface code on the union of the patches
The final edge measurement step is standard lattice surgery
Non-adjacent patches: For surface codes not directly adjacent, add a grid of dummy vertices between them in the gauging graph.
Extension to general codes: The same procedure works for any pair of matching logical \(X\) operators on two code blocks, provided:
Each code block has the same choice of \(G\) satisfying desiderata (ii) and (iii) from Remark 733
“Bridge” edges connect the two copies of \(G\)
Distance preservation: The gauging measurement preserves distance when individual logicals have minimal weight and contain no sub-logical operators.
This is a conceptual remark describing how the gauging measurement framework generalizes classical lattice surgery. We formalize:
Ladder graph structure: The specific gauging graph used for adjacent patches
Ladder connectivity: Proven path existence with explicit bounds
Vertex and edge counting: Explicit formulas for graph sizes
Non-adjacent extension: How dummy vertices scale with separation
Connection to Remark 733: The expansion property that enables distance arguments
No proof needed for remarks.
A vertex type for a ladder graph with \(n\) rungs. Each vertex is either on rail 1 or rail 2, at position \(0, \ldots , n-1\):
Rail 1 corresponds to the right edge of patch 1
Rail 2 corresponds to the left edge of patch 2
Formally, this is an inductive type:
For a ladder vertex \(v\), the rail index indicates which rail the vertex is on:
For a ladder vertex \(v\), the position is the index along the rail (\(0\) to \(n-1\)):
The constructor \(\texttt{rail1} : \text{Fin } n \to \texttt{LadderVertex}(n)\) is injective.
Let \(i, j : \text{Fin } n\) and suppose \(\texttt{rail1}(i) = \texttt{rail1}(j)\). By case analysis on this equality, we immediately have \(i = j\). This holds by reflexivity.
The constructor \(\texttt{rail2} : \text{Fin } n \to \texttt{LadderVertex}(n)\) is injective.
Let \(i, j : \text{Fin } n\) and suppose \(\texttt{rail2}(i) = \texttt{rail2}(j)\). By case analysis on this equality, we immediately have \(i = j\). This holds by reflexivity.
For any \(i, j : \text{Fin } n\), we have \(\texttt{rail1}(i) \neq \texttt{rail2}(j)\).
Suppose for contradiction that \(\texttt{rail1}(i) = \texttt{rail2}(j)\). By case analysis, this equality is impossible since these are distinct constructors of the inductive type.
For \(n \neq 0\), the cardinality of \(\texttt{LadderVertex}(n)\) is exactly \(2n\):
We establish an equivalence between \(\texttt{LadderVertex}(n)\) and \(\text{Fin } n \oplus \text{Fin } n\) by mapping \(\texttt{rail1}(i) \mapsto \text{inl}(i)\) and \(\texttt{rail2}(i) \mapsto \text{inr}(i)\). The cardinality of \(\text{Fin } n \oplus \text{Fin } n\) is \(|\text{Fin } n| + |\text{Fin } n| = n + n = 2n\).
Two ladder vertices \(v\) and \(w\) are connected by a rung edge if they are on opposite rails at the same position:
Two ladder vertices \(v\) and \(w\) are connected by a rail edge if they are on the same rail at consecutive positions:
Two ladder vertices are adjacent in the ladder graph if they are connected by either a rung edge or a rail edge:
Rung edges are symmetric: \(\texttt{isRungEdge}(v, w) \Leftrightarrow \texttt{isRungEdge}(w, v)\).
By case analysis on \(v\) and \(w\), using the symmetry of equality.
Rail edges are symmetric: \(\texttt{isRailEdge}(v, w) \Leftrightarrow \texttt{isRailEdge}(w, v)\).
By case analysis on \(v\) and \(w\), using commutativity of disjunction.
Ladder adjacency is symmetric: \(\texttt{isLadderAdjacent}(v, w) \Leftrightarrow \texttt{isLadderAdjacent}(w, v)\).
By unfolding the definition and applying symmetry of rung edges and rail edges.
Ladder adjacency is irreflexive (no self-loops): \(\neg \texttt{isLadderAdjacent}(v, v)\).
Assume \(\texttt{isLadderAdjacent}(v, v)\) for contradiction. By case analysis on \(v\):
If \(v = \texttt{rail1}(i)\): The rung edge condition is false (same rail), and the rail edge condition requires \(i + 1 = i\) or \(i + 1 = i\), which fails by integer arithmetic.
If \(v = \texttt{rail2}(i)\): Similarly, the conditions fail by integer arithmetic.
The number of rung edges in a ladder graph with \(n\) rungs is exactly \(n\) (one per position):
The number of rail edges per rail is \(n - 1\) (connecting consecutive positions):
The total number of rail edges (both rails) is \(2(n-1)\):
The total number of edges in a ladder graph:
For \(n \geq 1\), the ladder edge count equals \(3n - 2\):
By unfolding definitions: \(n + 2(n-1) = n + 2n - 2 = 3n - 2\). This follows by integer arithmetic.
The rung count equals the boundary size (the logical support size):
This holds by reflexivity (the definition of \(\texttt{ladderRungCount}\)).
The distance between positions \(i\) and \(j\) on a line:
Position distance is symmetric: \(\texttt{positionDistance}(i, j) = \texttt{positionDistance}(j, i)\).
By unfolding the definition and considering cases based on whether \(i \leq j\), \(j \leq i\). The result follows by integer arithmetic.
The distance from a position to itself is zero: \(\texttt{positionDistance}(i, i) = 0\).
By unfolding the definition: since \(i \leq i\), we have \(\texttt{positionDistance}(i, i) = i - i = 0\). This follows by simplification.
The path length between two ladder vertices:
Same rail: \(|i - j|\) rail edges
Different rails: \(|i - j|\) rail edges \(+ 1\) rung
Ladder distance is symmetric: \(\texttt{ladderDistance}(v, w) = \texttt{ladderDistance}(w, v)\).
By case analysis on \(v\) and \(w\), using the symmetry of position distance.
The ladder distance from a vertex to itself is zero: \(\texttt{ladderDistance}(v, v) = 0\).
By case analysis on \(v\), using that \(\texttt{positionDistance}(i, i) = 0\).
For \(n {\gt} 0\), the maximum ladder distance is \(2n - 1\) (corner to opposite corner):
By case analysis on \(v\) and \(w\). In each case, the position distance is at most \(n - 1\) (since positions are in \(\{ 0, \ldots , n-1\} \)). For same rail: distance \(\leq n - 1 {\lt} 2n - 1\). For different rails: distance \(\leq (n - 1) + 1 = n {\lt} 2n - 1\) when \(n {\gt} 1\), and equals \(2n - 1\) in the worst case (corners). This follows by integer arithmetic.
The ladder graph is connected: any two vertices have a path of bounded length.
We take \(d = \texttt{ladderDistance}(v, w)\). By reflexivity, \(d = \texttt{ladderDistance}(v, w)\). By the bounded distance theorem, \(d \leq 2n - 1\).
The diameter of the ladder graph is at most \(2n - 1\):
This is exactly the statement of the bounded distance theorem applied to all pairs of vertices.
Let \(S\) be a valid Cheeger subset. We apply the theorem that Cheeger constant \(\geq 1\) implies boundary \(\geq \) size.
When \(h(G) \geq 1\), no subset can have boundary smaller than itself. This prevents logical operators from finding “shortcuts” through the gauging graph, thereby preserving code distance:
This follows directly from the theorem that Cheeger constant \(\geq 1\) implies boundary \(\geq \) size.
Total vertices when patches are separated by \(\texttt{gap}\) intermediate positions:
This consists of:
\(2 \times \texttt{boundarySize}\) for the actual boundary vertices
\(\texttt{gap} \times \texttt{boundarySize}\) for dummy vertices filling the gap
The vertex count expands to:
By unfolding the definition: \((2 + \texttt{gap}) \times \texttt{boundarySize} = 2 \cdot \texttt{boundarySize} + \texttt{gap} \cdot \texttt{boundarySize}\). This follows by ring arithmetic.
Non-adjacent patches have at least as many vertices as adjacent patches (\(\texttt{gap} = 0\)):
By unfolding the definition: \((2 + \texttt{gap}) \times \texttt{boundarySize} \geq 2 \times \texttt{boundarySize}\) since \(\texttt{gap} \geq 0\). This follows by nonlinear integer arithmetic.
When \(\texttt{gap} {\gt} 0\) and \(\texttt{boundarySize} {\gt} 0\), strictly more vertices are needed:
By unfolding the definition: \((2 + \texttt{gap}) \times \texttt{boundarySize} {\gt} 2 \times \texttt{boundarySize}\) when \(\texttt{gap} {\gt} 0\) and \(\texttt{boundarySize} {\gt} 0\). This follows by nonlinear integer arithmetic.
Edge count for non-adjacent patches consists of rungs plus rail edges on each column:
For \(\texttt{boundarySize} \geq 1\), the edge count simplifies to:
We have \(\texttt{boundarySize} - 1 + 1 = \texttt{boundarySize}\) by the subtraction-addition cancellation. Also, \(2 \cdot \texttt{boundarySize} - 1 = \texttt{boundarySize} + (\texttt{boundarySize} - 1)\). Then:
This follows by ring arithmetic.
Number of bridge edges needed to connect two patches with common boundary size \(k\). Each boundary qubit on patch 1 connects to its counterpart on patch 2:
Bridge edges equal the common boundary (one edge per paired qubit):
This holds by reflexivity (definitional equality).
Total boundary vertices in a bridged configuration:
The bridge connects all boundary pairs: \(\texttt{bridgeEdgeCount}(k) = k\).
This holds by reflexivity.
For a bridged gauging graph to preserve distance, it must satisfy the sufficient expansion property (desideratum (ii) from Remark 733):
For the deformed code to be LDPC, the gauging graph must have a low-weight cycle basis (desideratum (iii) from Remark 733):
Combined desiderata for general code extension:
When both desiderata hold, the expansion property applies to all valid subsets:
Let \(S\) be a valid Cheeger subset. From the hypothesis, we have \(\texttt{SufficientExpansionProperty}(G)\) as the first component. We apply the theorem that Cheeger constant \(\geq 1\) implies boundary \(\geq \) size.
When the cycle bound holds, all cycles have bounded weight:
From the hypothesis, the second component gives \(\texttt{LowWeightCycleBasisProperty}(G, W)\), which is exactly the statement that all cycles have vertex count at most \(W\).
A logical operator has minimal weight if its support equals the code distance:
A logical has no sub-logicals if no proper subset of its support is also a logical:
Combined distance preservation conditions from the remark:
When logicals have minimal weight, distance cannot decrease due to weight:
By unfolding the definition, we have \(\texttt{logicalWeight} = \texttt{codeDistance}\). The inequality \(\texttt{logicalWeight} \geq \texttt{codeDistance}\) follows from the symmetry of equality.
No sub-logicals means the logical operator is “atomic”: for any proper subset \(T \subsetneq S\), we have \(\neg \texttt{isLogical}(T)\).
Let \(T\) be a proper subset of \(S\) (i.e., \(T \subsetneq S\)). By the hypothesis \(\texttt{NoSubLogicals}(S, \texttt{isLogical})\), we have \(\neg \texttt{isLogical}(T)\).
Summary: The ladder graph has exactly \(2n\) vertices:
This is exactly the statement of the ladder vertex cardinality theorem.
Summary: For \(n \geq 1\), the ladder graph has \(3n - 2\) edges:
This is exactly the ladder edge count formula.
Summary: The ladder graph is connected with bounded diameter \(2n - 1\):
This is exactly the ladder diameter theorem.
Summary: Non-adjacent patches scale linearly with boundary size:
This holds by reflexivity (definitional equality).
Summary: The expansion property enables distance arguments:
This follows by applying the theorem that sufficient expansion implies the graph is an expander.
[Relation to Shor Measurement]
The gauging measurement can recover Shor-style logical measurement. The key insight is:
Shor-style setup: Entangle an auxiliary GHZ state to the code via transversal CX gates, then measure \(X\) on auxiliary qubits.
Gauging equivalent: Use a graph \(G\) with:
A dummy vertex for each qubit in \(\mathrm{supp}(L)\), each connected by an edge to the corresponding code qubit (“rung edges”)
A connected subgraph on the dummy vertices (“dummy-connection edges”)
Process: If we measure the edges of the connected subgraph first (projecting dummies into a GHZ state), then measure the remaining edges, the result is equivalent to Shor-style measurement with \(X\) measurements commuted backward through CX gates.
The Shor graph is structurally similar to the ladder graph from Remark 2142, but with a different interpretation: the Shor graph is a degenerate ladder with one rail being the code and the other being a path of dummies.
No proof needed for remarks.
The vertex type for the Shor measurement graph. For a logical operator with support size \(n\):
\(\mathrm{code}(i)\) represents the \(i\)-th code qubit in \(\mathrm{supp}(L)\) for \(i \in \{ 0, \ldots , n-1\} \)
\(\mathrm{dummy}(i)\) represents the auxiliary dummy qubit for code qubit \(i\)
This is an inductive type with two constructors:
A predicate that returns true if and only if a Shor vertex is a code vertex:
A predicate that returns true if and only if a Shor vertex is a dummy vertex:
The index of a Shor vertex, extracting the underlying \(\mathrm{Fin}(n)\) value:
The code constructor is injective: for all \(i, j \in \mathrm{Fin}(n)\), if \(\mathrm{code}(i) = \mathrm{code}(j)\) then \(i = j\).
Let \(i, j \in \mathrm{Fin}(n)\) and assume \(\mathrm{code}(i) = \mathrm{code}(j)\). By case analysis on this equality (which is an equality of inductive constructors), we obtain \(i = j\). This holds by reflexivity.
The dummy constructor is injective: for all \(i, j \in \mathrm{Fin}(n)\), if \(\mathrm{dummy}(i) = \mathrm{dummy}(j)\) then \(i = j\).
Let \(i, j \in \mathrm{Fin}(n)\) and assume \(\mathrm{dummy}(i) = \mathrm{dummy}(j)\). By case analysis on this equality, we obtain \(i = j\). This holds by reflexivity.
For all \(i, j \in \mathrm{Fin}(n)\), \(\mathrm{code}(i) \neq \mathrm{dummy}(j)\).
Assume for contradiction that \(\mathrm{code}(i) = \mathrm{dummy}(j)\). By case analysis on this equality, we reach a contradiction since the constructors are different.
For all \(i, j \in \mathrm{Fin}(n)\), \(\mathrm{dummy}(i) \neq \mathrm{code}(j)\).
Assume for contradiction that \(\mathrm{dummy}(i) = \mathrm{code}(j)\). By case analysis on this equality, we reach a contradiction since the constructors are different.
For \(n \geq 1\), the cardinality of \(\texttt{ShorVertex}(n)\) is exactly \(2n\):
We establish a bijection between \(\texttt{ShorVertex}(n)\) and \(\mathrm{Fin}(n) \sqcup \mathrm{Fin}(n)\) (the disjoint union of two copies of \(\mathrm{Fin}(n)\)). The bijection maps \(\mathrm{code}(i)\) to the left injection and \(\mathrm{dummy}(i)\) to the right injection. Since the cardinality of \(\mathrm{Fin}(n) \sqcup \mathrm{Fin}(n)\) is \(n + n = 2n\), we conclude \(|\texttt{ShorVertex}(n)| = 2n\).
A rung edge connects code qubit \(i\) to dummy qubit \(i\):
A dummy-connection edge connects consecutive dummy qubits, forming a path:
Two vertices in the Shor graph are adjacent if they are connected by a rung edge or a dummy-connection edge:
Rung edges are symmetric: \(\mathrm{isRungEdgeShor}(v, w) \Leftrightarrow \mathrm{isRungEdgeShor}(w, v)\).
By case analysis on \(v\) and \(w\). In each case involving code and dummy vertices, the condition \(i = j\) is symmetric.
Dummy-connection edges are symmetric: \(\mathrm{isDummyConnectionEdge}(v, w) \Leftrightarrow \mathrm{isDummyConnectionEdge}(w, v)\).
By case analysis on \(v\) and \(w\). When both are dummy vertices, the condition \((i + 1 = j) \lor (j + 1 = i)\) is symmetric by commutativity of disjunction.
Shor adjacency is symmetric: \(\mathrm{isShorAdjacent}(v, w) \Leftrightarrow \mathrm{isShorAdjacent}(w, v)\).
Unfold the definition of \(\mathrm{isShorAdjacent}\) and apply the symmetry lemmas for rung edges and dummy-connection edges.
Shor adjacency is irreflexive: for all vertices \(v\), \(\neg \mathrm{isShorAdjacent}(v, v)\).
Assume \(\mathrm{isShorAdjacent}(v, v)\) holds. By case analysis on \(v\):
If \(v = \mathrm{code}(i)\): Both \(\mathrm{isRungEdgeShor}(v, v)\) and \(\mathrm{isDummyConnectionEdge}(v, v)\) are false by definition.
If \(v = \mathrm{dummy}(i)\): The rung edge condition is false. The dummy-connection condition requires \(i + 1 = i\) or \(i + 1 = i\), which is impossible by integer arithmetic.
In all cases we reach a contradiction.
The number of rung edges in the Shor graph: one per code/dummy pair.
The number of dummy-connection edges in the Shor graph, forming a path among \(n\) dummies:
The total number of edges in the Shor graph:
For \(n \geq 1\), the total edge count is \(2n - 1\):
Unfold the definitions: \(\mathrm{shorTotalEdgeCount}(n) = n + (n - 1) = 2n - 1\) by arithmetic.
The rung count equals the support size: \(\mathrm{shorRungCount}(n) = n\).
This holds by definition.
The cycle rank of the Shor graph, computed as \(|E| - |V| + 1\):
For \(n \geq 1\), the Shor graph has cycle rank 0, meaning it is a tree:
Unfold the definition: \(\mathrm{shorCycleRank}(n) = (2n - 1) - 2n + 1 = 0\) by integer arithmetic.
For a tree: \(|E| = |V| - 1\). Specifically, \(\mathrm{shorTotalEdgeCount}(n) = 2n - 1\).
This follows directly from Theorem 2218.
The dummy subgraph is a path of length \(n\):
The dummy subgraph has \(n - 1\) edges (forming a path):
The dummy subgraph has \(n\) vertices:
For \(n \geq 1\), the dummy subgraph is connected, satisfying \(|E| = |V| - 1\):
Unfold the definitions: \((n - 1) = n - 1\) holds by reflexivity.
The distance between two dummy vertices on the path:
Dummy distance is symmetric: \(\mathrm{dummyDistance}(i, j) = \mathrm{dummyDistance}(j, i)\).
By case analysis on whether \(i \leq j\) or \(j {\lt} i\). In each case, the result follows by integer arithmetic.
The distance from a vertex to itself is zero: \(\mathrm{dummyDistance}(i, i) = 0\).
Unfold the definition and simplify: since \(i \leq i\), we have \(\mathrm{dummyDistance}(i, i) = i - i = 0\).
For \(n {\gt} 0\), the maximum distance between any two dummy vertices is \(n - 1\):
By case analysis on whether \(i \leq j\). In either case, since \(i, j \in \mathrm{Fin}(n)\), we have \(0 \leq i, j {\lt} n\), so the difference is at most \(n - 1\) by integer arithmetic.
The number of measurements in Phase 1 (on the dummy subgraph):
The number of measurements in Phase 2 (on the rung edges):
The total measurements equals the total edges:
Unfold the definitions: \((n - 1) + n = n + (n - 1)\) by integer arithmetic.
Phase 1 measurements equal \(n - 1\): \(\mathrm{phase1MeasurementCount}(n) = n - 1\).
This holds by definition.
Phase 2 measurements equal \(n\): \(\mathrm{phase2MeasurementCount}(n) = n\).
This holds by definition.
The cycle rank of the dummy subgraph:
For \(n \geq 1\), the dummy subgraph has cycle rank 0:
Unfold the definitions: \((n - 1) - n + 1 = 0\) by integer arithmetic.
The number of flux operators on the dummy subgraph:
For a tree, there are no flux operators: \(\mathrm{dummyFluxOperatorCount}(n) = 0\) when \(n \geq 1\).
Unfold the definition of \(\mathrm{dummyFluxOperatorCount}\). By Theorem 2237, \(\mathrm{dummySubgraphCycleRank}(n) = 0\), so the condition \(\mathrm{dummySubgraphCycleRank}(n) {\gt} 0\) is false, and the result is 0.
A structure capturing the parameters of a Shor measurement graph:
\(\mathrm{supportSize} : \mathbb {N}\) – the support size of the logical operator
\(\mathrm{supportSize\_ pos} : 0 {\lt} \mathrm{supportSize}\) – proof that support size is positive
The total vertex count for a Shor graph: \(\mathrm{vertexCount}(p) = 2 \cdot p.\mathrm{supportSize}\).
The total edge count for a Shor graph: \(\mathrm{edgeCount}(p) = \mathrm{shorTotalEdgeCount}(p.\mathrm{supportSize})\).
The number of code qubits: \(\mathrm{codeQubitCount}(p) = p.\mathrm{supportSize}\).
The number of dummy qubits: \(\mathrm{dummyQubitCount}(p) = p.\mathrm{supportSize}\).
The cycle rank of the Shor graph: \(\mathrm{cycleRank}(p) = \mathrm{shorCycleRank}(p.\mathrm{supportSize})\).
The Shor graph is a tree: \(p.\mathrm{cycleRank} = 0\).
From the positivity condition \(p.\mathrm{supportSize\_ pos}\), we obtain \(1 \leq p.\mathrm{supportSize}\). Then apply Theorem 2221.
The vertex count formula: \(p.\mathrm{vertexCount} = 2 \cdot p.\mathrm{supportSize}\).
This holds by definition.
The edge count formula: \(p.\mathrm{edgeCount} = 2 \cdot p.\mathrm{supportSize} - 1\).
Unfold the definition and apply Theorem 2218 with the positivity condition.
The dummy qubit count equals the code qubit count: \(p.\mathrm{dummyQubitCount} = p.\mathrm{codeQubitCount}\).
This holds by definition.
The total number of auxiliary qubits for Shor measurement via gauging:
This includes \(n\) dummy qubits plus the edge qubits.
For \(n \geq 1\), the auxiliary qubit count is \(3n - 1\):
Unfold the definition: \(n + (2n - 1) = 3n - 1\) by integer arithmetic.
The number of auxiliary qubits for standard Shor measurement (the GHZ state):
Gauging-based Shor uses at least as many auxiliary qubits as standard Shor:
Unfold the definitions: \(n + \mathrm{shorTotalEdgeCount}(n) \geq n\) since \(\mathrm{shorTotalEdgeCount}(n) \geq 0\) by integer arithmetic.
The overhead ratio approaches 3 for large \(n\):
Unfold the definitions: \(n + (2n - 1) = 3n - 1 {\lt} 3n\) by integer arithmetic.
The Shor graph has the same vertex count as a ladder:
Rewrite using Theorem 2207 and the corresponding ladder cardinality theorem: both equal \(2n\).
The Shor graph has at most as many edges as a ladder:
Unfold the definitions: \(\mathrm{shorTotalEdgeCount}(n) = n + (n - 1)\) and \(\mathrm{ladderEdgeCount}(n) = n + 2(n - 1)\). We need \(n + (n - 1) \leq n + 2(n - 1)\), which follows from \(n - 1 \leq 2(n - 1)\) since \(2 {\gt} 0\).
For \(n \geq 2\), the Shor graph has strictly fewer edges than a ladder:
Unfold the definitions and apply addition on the left. We need \(n - 1 {\lt} 2(n - 1)\) when \(n \geq 2\). Since \(n - 1 \geq 1 {\gt} 0\), we have \(1 \cdot (n-1) {\lt} 2 \cdot (n-1)\) by multiplication.
The difference in edges is exactly \(n - 1\) (the missing rail on the code side):
Unfold the definitions: \((n + 2(n-1)) - (n + (n-1)) = 2(n-1) - (n-1) = n - 1\) by arithmetic.
Summary: The Shor graph vertex count is \(|\texttt{ShorVertex}(n)| = 2n\).
This is Theorem 2207.
Summary: The Shor graph edge count is \(\mathrm{shorTotalEdgeCount}(n) = 2n - 1\) for \(n \geq 1\).
This is Theorem 2218.
Summary: The Shor graph is a tree with \(\mathrm{shorCycleRank}(n) = 0\) for \(n \geq 1\).
This is Theorem 2221.
Summary: Phase 1 creates the GHZ state on dummies with \(n - 1\) measurements.
This is Theorem 2234.
Summary: Phase 2 measures the logical via rungs with \(n\) measurements.
This is Theorem 2235.
Helper: The Shor graph has exactly one more edge than the dummy subgraph per code qubit:
This holds by definition.
Helper: The graph has no cycles because it’s a tree: \(\mathrm{shorCycleRank}(n) = 0\) for \(n \geq 1\).
This is Theorem 2221.
The distance from a code vertex to a dummy vertex via the rung and path:
The maximum code-to-dummy distance is \(n\):
By Theorem 2230, \(\mathrm{dummyDistance}(i, j) \leq n - 1\). Therefore \(\mathrm{codeToDummyDistance}(i, j) = 1 + \mathrm{dummyDistance}(i, j) \leq 1 + (n - 1) = n\) by integer arithmetic.
The diameter of the Shor graph (corner to opposite corner):
The Shor diameter equals \(2n - 1\): \(\mathrm{shorDiameter}(n) = 2n - 1\).
This holds by definition.
The Shor graph diameter equals the edge count (both \(2n - 1\)) for \(n \geq 1\):
Unfold the definition of \(\mathrm{shorDiameter}\) and apply Theorem 2218: both equal \(2n - 1\).
[Relation to Cohen et al. Scheme]
The generalized (hypergraph) gauging measurement recovers the Cohen et al. scheme:
Cohen et al. construction (from reference [ ):
Restrict \(Z\)-type checks to support of an irreducible \(X\) logical
Add \(d\) layers of dummy vertices for each qubit in \(\mathrm{supp}(L)\)
Connect copies of each vertex via line graphs
Join vertices in each layer via a copy of the hypergraph
Gauging interpretation: This is exactly the generalized gauging measurement applied to the hypergraph defined by the restricted \(Z\) checks, with the specified layering structure.
Cross et al. modification: Use fewer than \(d\) layers, exploiting expansion in the logical’s Tanner subgraph.
Product measurement: The procedures in both references for measuring products of irreducible logicals are captured by adding edges between the corresponding ancilla graphs.
We formalize the structural parameters for these constructions:
Cohen construction: A structure with support size \(|L|\), number of dummy layers \(d\), and number of restricted \(Z\)-checks. The total vertices are \(|L| \times (d + 1)\) (code layer plus \(d\) dummy layers). The edges consist of line graph edges (\(|L| \times d\)) and hypergraph copy edges \(((d+1) \times |\mathrm{checks}|)\).
Cross et al. optimization: A reduced-layer construction using \(r {\lt} d\) layers when expansion is sufficient, achieving fault tolerance with fewer vertices (\(|L| \times (r+1)\)) and fewer edges.
Product measurement: For measuring products of \(k \geq 2\) logical operators, each logical has its own ancilla graph connected by additional edges. Minimum connecting edges form a spanning tree (\(k-1\) edges), while maximum uses a complete graph (\(k(k-1)/2\) edges).
No proof needed for remarks.
A Cohen construction is a structure consisting of:
\(\mathtt{supportSize} : \mathbb {N}\) — the size of the logical support \(|L|\)
\(\mathtt{numLayers} : \mathbb {N}\) — the number of dummy layers \(d\) (provides distance-\(d\) fault tolerance)
\(\mathtt{numChecks} : \mathbb {N}\) — the number of restricted \(Z\)-checks
\(\mathtt{support\_ pos}\) — a proof that \(0 {\lt} \mathtt{supportSize}\)
\(\mathtt{layers\_ pos}\) — a proof that \(0 {\lt} \mathtt{numLayers}\)
For a Cohen construction \(C\), the total number of vertices is
This includes the code layer (layer 0) and \(d\) dummy layers.
For a Cohen construction \(C\), the number of code vertices (layer 0 only) is
For a Cohen construction \(C\), the number of dummy vertices (layers 1 through \(d\)) is
For a Cohen construction \(C\):
Unfolding the definitions, we have:
This follows by ring arithmetic.
For a Cohen construction \(C\), the number of vertices per layer is
For a Cohen construction \(C\), the total number of layers (including the code layer) is
For a Cohen construction \(C\):
Unfolding the definitions:
This follows by ring arithmetic (commutativity of multiplication).
For a Cohen construction \(C\), the number of line graph edges (vertical connections between layers) is
Each qubit in \(\mathrm{supp}(L)\) has \(d\) edges connecting its copies across layers.
For a Cohen construction \(C\), the number of hypergraph copy edges (horizontal connections within each layer) is
Each layer contains a copy of the restricted hypergraph.
For a Cohen construction \(C\), the total number of edges is
For a Cohen construction \(C\):
This holds by reflexivity, as both are defined as \(C.\mathtt{supportSize} \times C.\mathtt{numLayers}\).
For a Cohen construction \(C\):
Unfolding the definition of \(\mathtt{totalVertices}\), we have \(C.\mathtt{supportSize} \times (C.\mathtt{numLayers} + 1)\). Since \(C.\mathtt{support\_ pos}\) gives \(0 {\lt} C.\mathtt{supportSize}\) and \(C.\mathtt{numLayers} + 1 {\gt} 0\) (as a successor is positive), the product is positive.
For a Cohen construction \(C\):
This follows since \(C.\mathtt{totalLayerCount} = C.\mathtt{numLayers} + 1\) is a successor, hence positive.
For a Cohen construction \(C\):
This holds by reflexivity, as both are defined as \(C.\mathtt{supportSize} \times C.\mathtt{numLayers}\).
For a Cohen construction \(C\), the fault distance (providing distance-\(d\) fault tolerance) is
For a Cohen construction \(C\):
This follows directly from \(C.\mathtt{layers\_ pos}\), which asserts \(0 {\lt} C.\mathtt{numLayers}\).
A Cross construction extends a Cohen construction with:
\(\mathtt{reducedLayers} : \mathbb {N}\) — the reduced number of layers (achieves fault tolerance via expansion)
\(\mathtt{layer\_ reduction}\) — a proof that \(\mathtt{reducedLayers} {\lt} \mathtt{numLayers}\)
\(\mathtt{reduced\_ pos}\) — a proof that \(0 {\lt} \mathtt{reducedLayers}\)
This captures the Cross et al. optimization that uses expansion properties to achieve fault tolerance with fewer layers.
For a Cross construction \(X\), the reduced total vertices is
For a Cross construction \(X\), the reduced number of line graph edges is
For a Cross construction \(X\), the reduced number of hypergraph copy edges is
For a Cross construction \(X\), the reduced total edges is
For a Cross construction \(X\), the vertex savings from the reduction is
For a Cross construction \(X\), the edge savings from the reduction is
For a Cross construction \(X\):
Unfolding the definitions, we need to show
We apply the fact that multiplication by a positive number preserves strict inequality. Since \(X.\mathtt{support\_ pos}\) gives \(0 {\lt} X.\mathtt{supportSize}\), it suffices to show \(X.\mathtt{reducedLayers} + 1 {\lt} X.\mathtt{numLayers} + 1\). This follows from \(X.\mathtt{layer\_ reduction}\) which states \(X.\mathtt{reducedLayers} {\lt} X.\mathtt{numLayers}\), by applying the successor function to both sides.
For a Cross construction \(X\):
Unfolding all definitions, we need to show:
We have:
\(X.\mathtt{supportSize} \times X.\mathtt{reducedLayers} {\lt} X.\mathtt{supportSize} \times X.\mathtt{numLayers}\) since \(X.\mathtt{layer\_ reduction}\) gives \(X.\mathtt{reducedLayers} {\lt} X.\mathtt{numLayers}\) and \(X.\mathtt{support\_ pos}\) gives \(0 {\lt} X.\mathtt{supportSize}\).
\((X.\mathtt{reducedLayers} + 1) \times X.\mathtt{numChecks} \leq (X.\mathtt{numLayers} + 1) \times X.\mathtt{numChecks}\) since \(X.\mathtt{reducedLayers} + 1 \leq X.\mathtt{numLayers} + 1\) (from \(X.\mathtt{layer\_ reduction}\)).
The result follows by integer arithmetic (omega).
For a Cross construction \(X\):
Unfolding the definitions of \(\mathtt{vertexSavings}\), \(\mathtt{reducedVertices}\), and \(\mathtt{totalVertices}\):
Since \(X.\mathtt{layer\_ reduction}\) gives \(X.\mathtt{reducedLayers} {\lt} X.\mathtt{numLayers}\), we have \(X.\mathtt{reducedLayers} \leq X.\mathtt{numLayers}\). Using the distributive property and subtraction:
This follows by integer arithmetic (omega).
For a Cross construction \(X\), the reduced fault distance is
For a Cross construction \(X\):
This follows directly from \(X.\mathtt{layer\_ reduction}\), which states \(X.\mathtt{reducedLayers} {\lt} X.\mathtt{numLayers}\).
For a Cross construction \(X\):
This follows directly from \(X.\mathtt{reduced\_ pos}\), which asserts \(0 {\lt} X.\mathtt{reducedLayers}\).
A product measurement structure consists of:
\(\mathtt{numLogicals} : \mathbb {N}\) — the number of logicals in the product
\(\mathtt{constructions} : \mathrm{Fin}(\mathtt{numLogicals}) \to \mathtt{CohenConstruction}\) — parameters for each logical’s ancilla graph
\(\mathtt{product\_ nontrivial}\) — a proof that \(2 \leq \mathtt{numLogicals}\)
This captures the setup for measuring products of multiple logical operators.
For a product measurement \(P\), the total vertices across all ancilla graphs is
For a product measurement \(P\), the total edges within individual ancilla graphs (before connection) is
For a product measurement \(P\), the minimum number of connecting edges (forming a spanning tree among the ancilla graphs) is
For a product measurement \(P\), the maximum number of connecting edges (forming a complete graph among ancilla graphs) is
For a product measurement \(P\):
Unfolding the definitions, we need to show
Let \(n = P.\mathtt{numLogicals}\). From \(P.\mathtt{product\_ nontrivial}\), we have \(n \geq 2\).
We show \(2(n-1) \leq n(n-1)\). Since \(n \geq 2\), we have \(2 \leq n\), so \(2(n-1) \leq n(n-1)\) by multiplying both sides of \(2 \leq n\) by \((n-1) \geq 1\). The result follows by integer arithmetic (omega).
For a product measurement \(P\):
Unfolding the definition, \(\mathtt{minConnectingEdges} = P.\mathtt{numLogicals} - 1\). From \(P.\mathtt{product\_ nontrivial}\), we have \(2 \leq P.\mathtt{numLogicals}\), so \(P.\mathtt{numLogicals} - 1 \geq 1 {\gt} 0\). This follows by integer arithmetic (omega).
For a product measurement \(P\), the total edges with minimal (spanning tree) connection is
For a product measurement \(P\), the total edges with maximal (complete graph) connection is
For a product measurement \(P\):
Unfolding the definitions, we need to show
This follows by adding \(P.\mathtt{internalEdges}\) to both sides of the inequality \(P.\mathtt{minConnectingEdges} \leq P.\mathtt{maxConnectingEdges}\) (Theorem 2306).
For a Cohen construction \(C\), the number of hypergraph copies is
For a Cohen construction \(C\), the number of line connections per qubit is
For a Cohen construction \(C\):
This holds by reflexivity, as \(\mathtt{hypergraphCopies}\) is defined as \(\mathtt{totalLayerCount}\), which equals \(C.\mathtt{numLayers} + 1\).
For a Cohen construction \(C\):
This holds by reflexivity, as \(\mathtt{lineConnectionsPerQubit}\) is defined as \(C.\mathtt{numLayers}\).
For a Cohen construction \(C\):
This holds by reflexivity, as it is the definition of \(\mathtt{totalVertices}\).
For a Cohen construction \(C\):
This holds by reflexivity, unfolding the definitions of \(\mathtt{totalEdges}\), \(\mathtt{lineGraphEdges}\), and \(\mathtt{hypergraphCopyEdges}\).
For a Cross construction \(X\):
This is exactly Theorem 2295.
For a Cross construction \(X\):
This is exactly Theorem 2296.
For a product measurement \(P\):
This is exactly Theorem 2307.
[CSS Code Initialization]
The generalized (hypergraph) gauging measurement can implement CSS code initialization:
Standard CSS initialization: Prepare \(|0\rangle ^{\otimes n}\), then measure X-type checks.
Gauging interpretation:
Start with a trivial code having one dummy vertex per X-type check
Apply generalized gauging using the hypergraph corresponding to Z-type checks
The “ungauging” step performs Z measurement on all qubits (read-out)
Steane-style measurement: Combine initialization gauging with a pairwise XX gauging measurement between data and ancilla blocks:
Initialize ancilla block via gauging (as above)
Apply gauging measurement of XX on matching qubit pairs
Ungauge to read out Z on all ancilla qubits
This recovers Steane’s method for fault-tolerant syndrome extraction.
The main mathematical content is that the CSS orthogonality condition (every X-check commutes with every Z-check) implies that all X-type checks lie in the kernel of the Z-check hypergraph transpose matrix. This is the algebraic foundation for “measuring X-checks via Z-hypergraph gauging”.
No proof needed for remarks.
A CSS (Calderbank-Shor-Steane) code consists of:
\(\mathtt{numQubits} : \mathbb {N}\) — the number of physical qubits (with \(\mathtt{numQubits} {\gt} 0\))
\(\mathtt{numXChecks} : \mathbb {N}\) — the number of X-type check generators
\(\mathtt{numZChecks} : \mathbb {N}\) — the number of Z-type check generators
\(\mathtt{xCheckSupport} : \mathrm{Fin}(\mathtt{numXChecks}) \to \mathrm{Finset}(\mathrm{Fin}(\mathtt{numQubits}))\) — the support of each X-type check (qubits where \(X\) acts)
\(\mathtt{zCheckSupport} : \mathrm{Fin}(\mathtt{numZChecks}) \to \mathrm{Finset}(\mathrm{Fin}(\mathtt{numQubits}))\) — the support of each Z-type check (qubits where \(Z\) acts)
subject to the conditions:
X-checks have non-empty support: for all \(i\), \(\mathtt{xCheckSupport}(i)\) is nonempty
Z-checks have non-empty support: for all \(i\), \(\mathtt{zCheckSupport}(i)\) is nonempty
CSS orthogonality: every X-check commutes with every Z-check, i.e., for all \(i, j\):
\[ |\mathtt{xCheckSupport}(i) \cap \mathtt{zCheckSupport}(j)| \equiv 0 \pmod{2} \]
For a CSS code \(C\), the number of logical qubits is defined as:
(Informally: \(n - r_X - r_Z\) where \(r_X, r_Z\) are the ranks of the X and Z check matrices.)
For a CSS code \(C\) and X-type check index \(i\), the weight of the X-type check is:
For a CSS code \(C\) and Z-type check index \(i\), the weight of the Z-type check is:
For a CSS code \(C\), the initialization hypergraph is the hypergraph with:
Vertices: \(\mathrm{Fin}(C.\mathtt{numQubits})\) (i.e., the physical qubits)
Hyperedge indices: \(\mathrm{Fin}(C.\mathtt{numZChecks})\) (i.e., the Z-type checks)
Hyperedge function: \(\mathtt{hyperedge}(e) := C.\mathtt{zCheckSupport}(e)\)
This hypergraph defines the “gauging structure” for CSS initialization.
For a CSS code \(C\), the vertex type of the initialization hypergraph equals \(\mathrm{Fin}(C.\mathtt{numQubits})\).
This holds by definition (reflexivity).
For a CSS code \(C\):
Unfolding the definitions of \(\mathtt{numEdges}\) and \(\mathtt{initializationHypergraph}\), we have that \(\mathtt{numEdges}\) is the cardinality of the edge index type, which is \(\mathrm{Fin}(C.\mathtt{numZChecks})\). The result follows by simplification using \(|\mathrm{Fin}(n)| = n\).
For a CSS code \(C\):
Unfolding the definitions of \(\mathtt{numVertices}\) and \(\mathtt{initializationHypergraph}\), we have that \(\mathtt{numVertices}\) is the cardinality of the vertex type, which is \(\mathrm{Fin}(C.\mathtt{numQubits})\). The result follows by simplification using \(|\mathrm{Fin}(n)| = n\).
For a CSS code \(C\) and X-check index \(i\), we define the X-check as an operator support function over \(\mathbb {Z}/2\mathbb {Z}\):
This is the indicator vector of the X-check support.
For a CSS code \(C\) and X-check index \(i\):
This is the algebraic foundation for CSS initialization via gauging: \(H^T \cdot x_i = 0\) where \(x_i\) is the indicator vector of the \(i\)-th X-check support.
Let \(e\) be an arbitrary edge index. We need to show that \((\mathtt{matrixVectorProduct})_e = 0\).
Expanding the matrix-vector product with the incidence matrix, we have:
where \(H[v,e] = 1\) if \(v \in \mathtt{zCheckSupport}(e)\) and \(0\) otherwise, and \(x_i[v] = 1\) if \(v \in \mathtt{xCheckSupport}(i)\) and \(0\) otherwise.
We first transform the product: for each vertex \(v\),
Therefore, the sum counts elements in the intersection:
By the CSS orthogonality condition, \(|\mathtt{xCheckSupport}(i) \cap \mathtt{zCheckSupport}(e)| \equiv 0 \pmod{2}\). Thus \((H^T \cdot x_i)_e = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).
For a CSS code \(C\) and X-check index \(i\):
X-checks commute with all Z-type hyperedge operators.
Rewriting using the characterization that \(\mathtt{commutesWithAllChecks}\) is equivalent to \(\mathtt{inKernelOfTranspose}\), this follows directly from the kernel theorem (Theorem 2329).
For a CSS code \(C\) and X-check index \(i\):
This means X-checks can be measured via the hypergraph gauging procedure.
By definition, \(\mathtt{measurableGroup}\) consists of operators that commute with all checks. By Theorem 2330, the X-check operator commutes with all checks, hence it belongs to the measurable group.
For a CSS code \(C\), the CSS initialization vertex type is an inductive type with two constructors:
\(\mathtt{qubit} : \mathrm{Fin}(C.\mathtt{numQubits}) \to \mathtt{CSSInitVertex}(C)\) — physical qubit vertices
\(\mathtt{dummy} : \mathrm{Fin}(C.\mathtt{numXChecks}) \to \mathtt{CSSInitVertex}(C)\) — dummy vertices (one per X-check)
In the gauging interpretation of CSS initialization, we start with a “trivial code” having one dummy vertex per X-type check. Each dummy corresponds to an X-check measurement outcome.
The constructor \(\mathtt{qubit} : \mathrm{Fin}(C.\mathtt{numQubits}) \to \mathtt{CSSInitVertex}(C)\) is injective.
Let \(i, j : \mathrm{Fin}(C.\mathtt{numQubits})\) and assume \(\mathtt{qubit}(i) = \mathtt{qubit}(j)\). By pattern matching on the equality, we obtain \(i = j\).
The constructor \(\mathtt{dummy} : \mathrm{Fin}(C.\mathtt{numXChecks}) \to \mathtt{CSSInitVertex}(C)\) is injective.
Let \(i, j : \mathrm{Fin}(C.\mathtt{numXChecks})\) and assume \(\mathtt{dummy}(i) = \mathtt{dummy}(j)\). By pattern matching on the equality, we obtain \(i = j\).
For any \(i : \mathrm{Fin}(C.\mathtt{numQubits})\) and \(j : \mathrm{Fin}(C.\mathtt{numXChecks})\):
Assume for contradiction that \(\mathtt{qubit}(i) = \mathtt{dummy}(j)\). Pattern matching on this equality leads to a contradiction since the constructors are distinct.
For a CSS code \(C\):
Total vertices = qubits + dummies (one dummy per X-check).
We establish a bijection between \(\mathtt{CSSInitVertex}(C)\) and \(\mathrm{Fin}(C.\mathtt{numQubits}) \oplus \mathrm{Fin}(C.\mathtt{numXChecks})\) via:
with inverse:
This bijection preserves cardinality, so:
For \(n : \mathbb {N}\), the Steane vertex type is an inductive type with two constructors:
\(\mathtt{data} : \mathrm{Fin}(n) \to \mathtt{SteaneVertex}(n)\) — data block qubits
\(\mathtt{ancilla} : \mathrm{Fin}(n) \to \mathtt{SteaneVertex}(n)\) — ancilla block qubits
This represents the data/ancilla block structure for Steane-style fault-tolerant syndrome extraction.
For a Steane vertex \(v : \mathtt{SteaneVertex}(n)\), its index is defined by:
The constructor \(\mathtt{data} : \mathrm{Fin}(n) \to \mathtt{SteaneVertex}(n)\) is injective.
Let \(i, j : \mathrm{Fin}(n)\) and assume \(\mathtt{data}(i) = \mathtt{data}(j)\). By pattern matching on the equality, we obtain \(i = j\).
The constructor \(\mathtt{ancilla} : \mathrm{Fin}(n) \to \mathtt{SteaneVertex}(n)\) is injective.
Let \(i, j : \mathrm{Fin}(n)\) and assume \(\mathtt{ancilla}(i) = \mathtt{ancilla}(j)\). By pattern matching on the equality, we obtain \(i = j\).
For any \(i, j : \mathrm{Fin}(n)\):
Assume for contradiction that \(\mathtt{data}(i) = \mathtt{ancilla}(j)\). Pattern matching on this equality leads to a contradiction since the constructors are distinct.
For \(n : \mathbb {N}\) with \(n \neq 0\):
Total Steane vertices = data block + ancilla block.
We establish a bijection between \(\mathtt{SteaneVertex}(n)\) and \(\mathrm{Fin}(n) \oplus \mathrm{Fin}(n)\) via:
with inverse:
This bijection preserves cardinality, so:
For \(n : \mathbb {N}\) with \(n \neq 0\) and \(i : \mathrm{Fin}(n)\), the pairwise XX operator support is:
This represents the \(XX\) operator on matching qubit pairs (data[i] and ancilla[i]) for Steane measurement.
For \(n : \mathbb {N}\) with \(n \neq 0\) and \(i : \mathrm{Fin}(n)\):
Each XX operator acts on exactly 2 qubits: \(\mathtt{data}(i)\) and \(\mathtt{ancilla}(i)\).
We show that the set \(\{ v \mid \mathtt{pairwiseXXSupport}(i)(v) = 1\} \) equals \(\{ \mathtt{data}(i), \mathtt{ancilla}(i)\} \).
For the forward inclusion: let \(v\) be such that \(\mathtt{pairwiseXXSupport}(i)(v) = 1\). We case split on \(v\):
If \(v = \mathtt{data}(j)\): By definition, \(\mathtt{pairwiseXXSupport}(i)(v) = 1\) only when \(j = i\), so \(v = \mathtt{data}(i)\).
If \(v = \mathtt{ancilla}(j)\): By definition, \(\mathtt{pairwiseXXSupport}(i)(v) = 1\) only when \(j = i\), so \(v = \mathtt{ancilla}(i)\).
For the reverse inclusion: by definition, \(\mathtt{pairwiseXXSupport}(i)(\mathtt{data}(i)) = 1\) and \(\mathtt{pairwiseXXSupport}(i)(\mathtt{ancilla}(i)) = 1\).
Since \(\mathtt{data}(i) \neq \mathtt{ancilla}(i)\) by Lemma 2341, we have:
For a CSS code \(C\), the identity operator (constant zero function) is in the measurable group:
This follows directly from the fact that the zero operator is always in the measurable group.
For a CSS code \(C\) and X-check indices \(i, j\), the sum (XOR) of X-checks is in the measurable group:
The measurable group is closed under addition in \(\mathbb {Z}/2\mathbb {Z}\).
We apply the closure of the measurable group under addition. By Theorem 2331, both \(C.\mathtt{xCheckAsOperator}(i)\) and \(C.\mathtt{xCheckAsOperator}(j)\) are in the measurable group. The result follows.
For a CSS code \(C\), X-check index \(i\), and vertex \(v\) with \(v \in C.\mathtt{xCheckSupport}(i)\):
By definition of \(\mathtt{xCheckAsOperator}\), when \(v \in C.\mathtt{xCheckSupport}(i)\), the if-then-else evaluates to \(1\).
For a CSS code \(C\), X-check index \(i\), and vertex \(v\) with \(v \notin C.\mathtt{xCheckSupport}(i)\):
By definition of \(\mathtt{xCheckAsOperator}\), when \(v \notin C.\mathtt{xCheckSupport}(i)\), the if-then-else evaluates to \(0\).
For a CSS code \(C\) and X-check index \(i\):
By definition, \(\mathtt{xCheckWeight}(i) = |C.\mathtt{xCheckSupport}(i)|\). Since \(C.\mathtt{xCheckSupport}(i)\) is nonempty by the CSS code axiom \(\mathtt{xCheck\_ nonempty}\), its cardinality is positive.
For a CSS code \(C\) and Z-check index \(i\):
By definition, \(\mathtt{zCheckWeight}(i) = |C.\mathtt{zCheckSupport}(i)|\). Since \(C.\mathtt{zCheckSupport}(i)\) is nonempty by the CSS code axiom \(\mathtt{zCheck\_ nonempty}\), its cardinality is positive.
1.21 Corollary 1: Qubit Overhead Bound
This section establishes the main overhead bound for the gauging measurement procedure. For an arbitrary Pauli operator \(L\) of weight \(W\), the worst-case qubit overhead is \(O(W \log ^2 W)\).
1.21.1 Auxiliary Qubit Count
The number of auxiliary qubits in the gauging procedure consists of:
Edge qubits from the original graph \(G\): \(|E_G|\)
Edge qubits from inter-layer connections: \(O(W \cdot R)\)
Edge qubits from cellulation: bounded by cycle count
For the worst-case construction with \(R = O(\log ^2 W)\), this gives \(O(W \log ^2 W)\) total.
The formula for auxiliary qubit count in a cycle-sparsified graph is defined as:
Given \(W\) vertices and \(R\) layers:
Original edges: at most \(\frac{d}{2} \cdot W\) for degree-\(d\) graph
Inter-layer edges: at most \(W \cdot R\) (one per vertex per layer boundary)
Cellulation edges: bounded by cycle sparsification
Total: \(O(W) + O(W \cdot R) = O(W \cdot R)\) for \(R \geq 1\).
Alternative formula including explicit layer count:
The two definitions are equivalent:
This holds by reflexivity of the definitions.
For all \(W, R_1, R_2 \in \mathbb {N}\), if \(R_1 \leq R_2\), then:
Unfolding the definition, we have \(\mathrm{auxiliaryQubitCount}(W, R) = W \cdot (R + 1)\). Since multiplication by \(W\) preserves the ordering and \(R_1 + 1 \leq R_2 + 1\) when \(R_1 \leq R_2\), the result follows by linear arithmetic.
For all \(W_1, W_2, R \in \mathbb {N}\), if \(W_1 \leq W_2\), then:
Unfolding the definition, we need \(W_1 \cdot (R + 1) \leq W_2 \cdot (R + 1)\). This follows directly from the fact that multiplication on the right by \((R+1)\) is monotone.
For all \(W, R \in \mathbb {N}\):
Unfolding the definition, we have:
The first inequality holds since \(R + 1 \geq 1\) for all \(R \in \mathbb {N}\).
1.21.2 Overhead Bound
The main overhead bound: for \(R \leq O(\log ^2 W)\), the auxiliary qubit count is \(O(W \log ^2 W)\).
The overhead bound formula is:
The overhead bound as a function:
For all \(W \in \mathbb {N}\):
This holds by reflexivity of the definition.
Given the Freedman-Hastings bound \(R \leq (\log _2 W)^2 + 1\), the auxiliary qubit count is at most \(W \cdot ((\log _2 W)^2 + 2)\):
If \(R \leq (\log _2 W)^2 + 1\), then:
Unfolding the definitions, we need to show \(W \cdot (R + 1) \leq W \cdot ((\log _2 W)^2 + 2)\). By the assumption \(R \leq (\log _2 W)^2 + 1\), we have \(R + 1 \leq (\log _2 W)^2 + 2\). Multiplying both sides by \(W\) gives the result.
The overhead is \(O(W \log ^2 W)\) in the sense that \(\mathrm{overheadBound}(W) \leq C \cdot W \cdot ((\log _2 W)^2 + 1)\) for \(C = 2\):
Unfolding the definition, we need:
Using ring arithmetic, the left side equals \(W \cdot (\log _2 W)^2 + 2W\) and the right side equals \(2W \cdot (\log _2 W)^2 + 2W\). Since \(W \cdot (\log _2 W)^2 \leq 2W \cdot (\log _2 W)^2\) (as \(1 \leq 2\)), the inequality holds by linear arithmetic.
The overhead function is \(O(W \log ^2 W)\) in the IsO sense:
We exhibit constants \(C = 2\) and \(N_0 = 1\). For all \(n \geq N_0\), by the overhead asymptotic bound theorem, we have \(\mathrm{overheadBound}(n) \leq 2 \cdot (n \cdot ((\log _2 n)^2 + 1))\).
1.21.3 LDPC Preservation
The deformed code is LDPC when:
The original code is LDPC (check weight \(\leq w\), qubit degree \(\leq d_{\text{orig}}\))
The gauging graph has constant degree \(\Delta \)
Path lengths are bounded by \(\kappa \)
Cycle sparsification achieves constant cycle-degree \(c\)
Then the deformed code satisfies:
Check weight \(\leq \max (\Delta +1, 4, w+\kappa )\)
Qubit degree \(\leq 2\Delta ^\kappa \cdot w + c + 2\)
A structure capturing the LDPC parameters before and after deformation:
\(\mathrm{originalCheckWeight}\): Original code’s maximum check weight
\(\mathrm{originalQubitDegree}\): Original code’s maximum qubit degree
\(\mathrm{graphDegree}\): Gauging graph degree
\(\mathrm{pathLengthBound}\): Maximum path length for deformation
\(\mathrm{cycleDegree}\): Cycle degree after sparsification
The deformed code’s check weight bound:
The deformed code’s qubit degree bound:
Check weight is bounded by the explicit formula:
This holds by reflexivity of the definition.
Qubit degree is bounded by the explicit formula:
This holds by reflexivity of the definition.
Both bounds are finite (and hence constants when parameters are constants):
Both inequalities hold trivially by linear arithmetic since \(n {\lt} n + 1\) for all natural numbers \(n\).
The deformed code is LDPC with bounded check weight:
Gauss law operators: \(\mathrm{graphDegree}(p) + 1 \leq \mathrm{deformedCheckWeight}(p)\)
Flux operators: \(4\leq \mathrm{deformedCheckWeight}(p)\)
Deformed checks: \(\mathrm{originalCheckWeight}(p) + \mathrm{pathLengthBound}(p) \leq \mathrm{deformedCheckWeight}(p)\)
Unfolding the definition of deformed check weight:
The first inequality follows from \(\mathrm{graphDegree}(p) + 1 \leq \max (\mathrm{graphDegree}(p) + 1, \ldots )\) by the left maximum property.
For the second inequality, we have \(4 \leq \max (4, \mathrm{originalCheckWeight}(p) + \mathrm{pathLengthBound}(p))\) by the left maximum property, and then this is at most the outer maximum by the right maximum property.
Similarly, \(\mathrm{originalCheckWeight}(p) + \mathrm{pathLengthBound}(p) \leq \max (4, \mathrm{originalCheckWeight}(p) + \mathrm{pathLengthBound}(p))\) by the right maximum property, and this is at most the outer maximum by the right maximum property.
The deformed code is LDPC with bounded qubit degree. The formula gives a finite bound:
This holds by reflexivity of the definition.
Combined LDPC result:
\(\mathrm{graphDegree}(p) + 1 \leq \mathrm{deformedCheckWeight}(p)\)
\(4 \leq \mathrm{deformedCheckWeight}(p)\)
\(\mathrm{originalCheckWeight}(p) + \mathrm{pathLengthBound}(p) \leq \mathrm{deformedCheckWeight}(p)\)
\(\mathrm{deformedQubitDegree}(p) = 2 \cdot \mathrm{graphDegree}(p)^{\mathrm{pathLengthBound}(p)} \cdot \mathrm{originalCheckWeight}(p) + \mathrm{cycleDegree}(p) + 2\)
The first three properties follow from the deformed check weight bounded theorem. The fourth property holds by reflexivity of the definition.
1.21.4 Main Corollary
Configuration for the qubit overhead bound:
\(\mathrm{logicalWeight}\): Weight of the logical operator \(|L| = W\)
\(\mathrm{weight\_ ge\_ 2}\): \(W \geq 2\) (non-trivial logical operator)
\(\mathrm{ldpcParams}\): LDPC parameters of the original code
The gauging measurement procedure for an arbitrary Pauli operator \(L\) of weight \(W\) has worst-case qubit overhead \(O(W \log ^2 W)\).
Specifically, given a configuration:
Part 1 (Overhead bound): There exists \(R \leq (\log _2 W)^2 + 1\) such that
\[ \mathrm{auxiliaryQubitCount}(W, R) \leq \mathrm{overheadBound}(W) \]Part 2 (Asymptotic bound):
\[ \mathrm{overheadBound}(W) \leq 2 \cdot (W \cdot ((\log _2 W)^2 + 1)) \]Part 3 (LDPC preservation):
\(\mathrm{graphDegree} + 1 \leq \mathrm{deformedCheckWeight}\)
\(4 \leq \mathrm{deformedCheckWeight}\)
\(\mathrm{originalCheckWeight} + \mathrm{pathLengthBound} \leq \mathrm{deformedCheckWeight}\)
This follows from:
The Freedman-Hastings decongestion lemma: \(R = O(\log ^2 W)\) layers suffice
The worst-case construction from Remark 9
The LDPC analysis from Remark 7
Part 1: We choose \(R = (\log _2 W)^2 + 1\). Then \(R \leq (\log _2 W)^2 + 1\) holds by reflexivity, and the bound on auxiliary qubit count follows from the auxiliary qubit count bound theorem with the reflexivity witness.
Part 2: This follows directly from the overhead asymptotic bound theorem applied to \(W\).
Part 3: This follows directly from the deformed check weight bounded theorem applied to the LDPC parameters.
The qubit overhead formula as a specification:
The overhead satisfies the specification:
We choose \(C = 2\). Since \(2 {\gt} 0\), we need to show that for all \(W' \geq 1\), we have \(\mathrm{overheadBound}(W') \leq 2 \cdot (W' \cdot ((\log _2 W')^2 + 1))\). This follows directly from the overhead asymptotic bound theorem.
1.21.5 Edge Count Bounds
The edge count in the sparsified graph relates to the auxiliary qubit count.
Edge count in the layered graph:
where:
Intra-layer edges: at most \(\frac{\Delta }{2} \cdot W\) per layer, times \((R+1)\) layers
Inter-layer edges: at most \(\Delta \cdot W\) per layer boundary, times \(R\) boundaries
Edge count is \(O(W \cdot R)\) for constant \(\Delta \):
Unfolding the definition, we bound each term:
\(\frac{\Delta \cdot W}{2} \cdot (R + 1) \leq (\Delta \cdot W) \cdot (R + 1)\) since division by 2 gives a value at most the original.
\(\Delta \cdot W \cdot R \leq \Delta \cdot W \cdot (R + 1)\) since \(R \leq R + 1\).
Adding these: \((\Delta \cdot W) \cdot (R + 1) + \Delta \cdot W \cdot (R + 1) = 2\Delta \cdot W \cdot (R + 1)\). Since \(2\Delta \leq \Delta + 2\Delta \), we have \(2\Delta \cdot W \cdot (R + 1) \leq (\Delta + 2\Delta ) \cdot W \cdot (R + 1)\).
Edge count with \(R = O(\log ^2 W)\) gives \(O(W \log ^2 W)\):
By the edge count bound auxiliary theorem with \(R = (\log _2 W)^2 + 1\):
Using ring arithmetic, \((\log _2 W)^2 + 1 + 1 = (\log _2 W)^2 + 2\).
1.21.6 Helper Lemmas
Overhead for \(W = 2\):
This holds by reflexivity of the definition.
Overhead for \(W = 4\):
This holds by reflexivity of the definition.
\(\log _2 4 = 2\).
This is verified by computation (decide).
Overhead of 4 in terms of constants:
Unfolding the definitions and using \(\log _2 4 = 2\), we have \((\log _2 4)^2 = 4\), so \(\mathrm{overheadBound}(4) = 4 \cdot (4 + 2)\) by ring arithmetic.
The overhead is at least \(W\):
Unfolding the definition, we have \(1 \leq (\log _2 W)^2 + 2\) by linear arithmetic. Therefore:
The overhead is monotone in \(W\) for \(W \geq 2\): if \(W_1 \geq 2\) and \(W_1 \leq W_2\), then:
Unfolding the definition, we need to show \(W_1 \cdot ((\log _2 W_1)^2 + 2) \leq W_2 \cdot ((\log _2 W_2)^2 + 2)\).
Since \(W_1 \leq W_2\), we have \(\log _2 W_1 \leq \log _2 W_2\) by monotonicity of logarithm. Thus \((\log _2 W_1)^2 \leq (\log _2 W_2)^2\) since squaring preserves order for non-negative numbers.
We calculate:
where the first inequality uses \(W_1 \leq W_2\) and the second uses \((\log _2 W_1)^2 + 2 \leq (\log _2 W_2)^2 + 2\).
The construction uses at most \(O(W \log ^2 W)\) auxiliary qubits. The worst-case construction from Remark 9 achieves:
Vertex count \(\leq W \cdot ((\log _2 W)^2 + 2)\), i.e., \(W \cdot ((\log _2 W)^2 + 2) = \mathrm{overheadBound}(W)\)
This is at least \(W\): \(\mathrm{overheadBound}(W) \geq W\)
The first statement holds by reflexivity of the definition. The second statement follows from the overhead at least \(W\) theorem.
Relating to the hierarchy from CycleSparsificationBounds. For \(W \geq 4\):
Structured graphs: \(\mathrm{overheadBoundFunc}(\mathrm{structured}, W) \leq \mathrm{overheadBound}(W)\)
Expander graphs: \(\mathrm{overheadBoundFunc}(\mathrm{expander}, W) \leq \mathrm{overheadBound}(W)\)
General graphs: \(\mathrm{overheadBoundFunc}(\mathrm{general}, W) \leq \mathrm{overheadBound}(W)\)
We apply the overhead hierarchy theorem and then verify each case:
Structured \(\leq \) overhead:
by the overhead at least \(W\) theorem.
Expander \(\leq \) overhead:
We show \(W \cdot (\log _2 W + 1) \leq W \cdot ((\log _2 W)^2 + 2)\). It suffices to show \(\log _2 W + 1 \leq (\log _2 W)^2 + 2\).
Since \(W \geq 4\), we have \(\log _2 W \geq \log _2 4 = 2\). For \(\log _2 W \geq 2\):
Thus \(\log _2 W + 1 \leq (\log _2 W)^2 + 2\) by linear arithmetic.
General \(\leq \) overhead:
since \((\log _2 W)^2 + 1 \leq (\log _2 W)^2 + 2\) by linear arithmetic.
Summary of the qubit overhead bound corollary. For \(W \geq 2\):
The overhead formula: \(\mathrm{overheadBound}(W) = W \cdot ((\log _2 W)^2 + 2)\)
It’s at least \(W\): \(\mathrm{overheadBound}(W) \geq W\)
It’s \(O(W \log ^2 W)\): \(\mathrm{overheadBound} \in O(n \mapsto n \cdot ((\log _2 n)^2 + 1))\)
The first statement holds by reflexivity of the definition. The second follows from the overhead at least \(W\) theorem. The third follows from the overhead is \(O(W \log ^2 W)\) theorem.
[Nonabelian Generalization]
The gauging measurement procedure can be generalized beyond Pauli operators:
Finite group generalization: The procedure applies to any representation of a finite group \(G\) by operators with tensor product factorization. This includes:
Qudit systems (using \(\mathbb {Z}_d\) instead of \(\mathbb {Z}_2\))
Non-Pauli operators (e.g., Clifford operators in topological codes)
Magic state preparation via measurement of non-Clifford operators
Nonabelian case: For nonabelian groups, measuring local charges does not fix a definite global charge. The total charge is a superposition consistent with local outcomes.
Example: Measurement of Clifford operators in topological codes uses similar gauging ideas to produce magic states.
Mathematical content:
Abelian groups: product of local charges = global charge (exact)
Nonabelian groups: global charge is determined up to commutator
No proof needed for remarks.
A local charge configuration for a group \(G\) and a finite set of sites \(S\) assigns a group element to each site. For gauging measurement, this represents the outcome of measuring local charge operators.
Formally, it consists of a function \(\text{charge} : S \to G\).
The identity configuration is the local charge configuration where all charges are the identity element: \(\text{charge}(s) = 1\) for all sites \(s\).
The pointwise multiplication of two charge configurations \(c_1\) and \(c_2\) is defined by:
The pointwise inverse of a charge configuration \(c\) is defined by:
For any site \(s\), the identity configuration has \((1).\text{charge}(s) = 1\).
This holds by reflexivity (definition of identity configuration).
For any charge configurations \(c_1, c_2\) and site \(s\):
This holds by reflexivity (definition of multiplication).
For any charge configuration \(c\) and site \(s\):
This holds by reflexivity (definition of inverse).
For abelian groups \(G\), the global charge of a local charge configuration \(c\) is the product of all local charges:
For abelian groups, the global charge is the product of local charges:
This theorem justifies the gauging measurement procedure for Pauli operators: \(\prod _v \varepsilon _v = \sigma \) gives the logical measurement outcome.
This holds by reflexivity (definition of global charge).
Global charge is multiplicative under configuration multiplication:
Unfolding the definition of global charge, we have:
By the definition of multiplication, this equals:
Rewriting using the distributivity of products, we obtain:
The global charge of the identity configuration is the identity:
Unfolding the definition of global charge, we have:
using the fact that the product of constant ones equals one.
The global charge of an inverse configuration is the inverse of the global charge:
Unfolding the definition of global charge, we have:
By the distributivity of inverses over products, this equals:
A qudit charge configuration for dimension \(d\) is a local charge configuration valued in \(\text{Multiplicative}(\mathbb {Z}_d)\):
The global qudit charge is the sum of local charges (in additive notation):
The global qudit charge agrees with the global charge via the multiplicative-additive isomorphism:
We proceed by induction on the finite set of sites.
Base case (empty set): Both sides equal the identity by simplification.
Inductive step: For a site \(s\) not in \(S\), we have:
and similarly for the product. Rewriting using the fact that \(\text{ofAdd}(a + b) = \text{ofAdd}(a) \cdot \text{ofAdd}(b)\) and applying the induction hypothesis completes the proof.
The qubit case (\(d = 2\)) gives \(\mathbb {Z}_2\) charges (Pauli X measurement outcomes):
This holds by reflexivity (definition of qudit charge configuration with \(d = 2\)).
The qubit global charge is the sum of local charges modulo 2:
This holds by reflexivity (definition of global qudit charge).
The commutator subgroup \([G, G] = \langle g, h \mid g, h \in G \rangle \) measures the ambiguity in global charge. It is defined as the commutator of the top subgroup with itself:
For groups where all elements commute, the commutator subgroup is trivial:
We rewrite the commutator subgroup using the characterization that \([G, G] = \bot \) if and only if \(G \leq C_G(G)\) (the centralizer). We need to show that for any \(x \in G\), \(x\) is in the centralizer of \(G\), i.e., \(x\) commutes with all elements. But this follows directly from the hypothesis that all elements commute: for any \(y \in G\), we have \(x \cdot y = y \cdot x\) by assumption.
If the commutator subgroup is trivial, then all elements commute:
Let \(a, b \in G\). The commutator \([a, b] = a \cdot b \cdot a^{-1} \cdot b^{-1}\) is an element of the commutator subgroup \([G, G]\) by definition (since \(a, b \in G = \top \)). Since \([G, G] = \bot \), we have \([a, b] = 1\), i.e., \(a \cdot b \cdot a^{-1} \cdot b^{-1} = 1\). Therefore:
using group arithmetic.
The commutator subgroup is trivial if and only if all elements commute:
The commutator subgroup is a normal subgroup of \(G\).
The commutator subgroup \([G, G] = [\top , \top ]\) is normal by the standard result that commutator subgroups are always normal.
For nonabelian groups, the ordered product of local charges depends on an enumeration of the sites. Given an enumeration \(\text{enum} : \text{Fin}(|S|) \cong S\):
where the product is taken in order.
For abelian groups, the ordered product equals the unordered product:
Unfolding the definitions, we have:
This product over \(\text{Fin}(|S|)\) can be reindexed via the equivalence \(\text{enum}\) to give:
The reindexing is valid because multiplication in abelian groups is commutative.
The identity configuration has global ordered charge 1 for any enumeration:
Unfolding the definition of global ordered charge, we have:
using simplification with constant ones and the fact that the product of ones is one.
The constant configuration for a group element \(g\) assigns \(g\) to every site:
For abelian groups, the global charge of a constant configuration is \(g^{|S|}\):
Unfolding the definitions, we have:
using the fact that the product of a constant equals the constant raised to the cardinality power.
For any group, the global ordered charge of a constant configuration is \(g^{|S|}\):
Unfolding the definitions, we have:
using simplification with constant values and the product replicate formula.
For \(\mathbb {Z}_d\), the global charge of a constant configuration is \(|S| \cdot g\):
Unfolding the definitions, we have:
using the fact that \(\text{toAdd}(\text{ofAdd}(g)) = g\) and the sum of a constant equals the scalar multiple.
For abelian charge groups, the gauging measurement correctly determines the global charge from local measurements:
This holds by reflexivity (definition of global charge).
For \(\mathbb {Z}_2\) (Pauli case), the global charge is the parity of local outcomes:
This holds by reflexivity (definition of global qudit charge).
For nonabelian groups, different enumerations can give different global charges. The commutator subgroup controls this ambiguity:
Assume for contradiction that \([G, G] = \bot \) (the trivial subgroup). Let \(a, b\) be elements such that \(a \cdot b \neq b \cdot a\). By Theorem 2407, if \([G, G] = \bot \), then all elements commute. In particular, \(a \cdot b = b \cdot a\). This contradicts our assumption, so \([G, G] \neq \bot \).
For the constant configuration with value \(g\):
This holds by reflexivity (definition of constant configuration).
The global charge of the identity configuration is the identity:
This follows directly from Theorem 2398.
The global qudit charge of the identity configuration is zero:
Unfolding the definition of global qudit charge, we have:
using simplification with the identity charge and constant zero sum.
For empty sites (cardinality zero), the global charge is 1:
Unfolding the definition of global charge, if \(|S| = 0\), then the universal set of sites is empty. We verify this by showing that any element \(x\) would imply \(|S| {\gt} 0\) by positivity of cardinality when inhabited, which contradicts \(|S| = 0\). Therefore \(S = \emptyset \), and the product over the empty set equals 1.
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
You’ve hit your limit \(\cdot \) resets 7pm (America/New_York)
A binary vector of length \(n\) is a function \(v : \{ 0, 1, \ldots , n-1\} \to \mathbb {Z}/2\mathbb {Z}\).
The Hamming weight of a binary vector \(v \in (\mathbb {Z}/2\mathbb {Z})^n\) is the number of nonzero entries:
The zero vector has Hamming weight \(0\): \(\operatorname {wt}(\mathbf{0}) = 0\).
Unfolding the definition of Hamming weight, we need to count elements \(i\) such that \(0 \neq 0\). By simplification, the filter is empty since \(0 = 0\) for all entries, so the cardinality is \(0\).
A classical linear code over \(\mathbb {F}_2\) with \(n\) bits and \(r\) parity check constraints is represented by a parity check matrix \(H \in \mathbb {F}_2^{r \times n}\). The code is the kernel of \(H\):
A vector \(v \in \mathbb {F}_2^n\) is a codeword of a classical linear code \(C\) with parity check matrix \(H\) if \(Hv = 0\).
The syndrome of a vector \(v \in \mathbb {F}_2^n\) under parity check matrix \(H\) is \(Hv \in \mathbb {F}_2^r\).
The zero vector is always a codeword of any classical linear code.
Unfolding the definition of codeword, we need \(Hv = 0\) where \(v = \mathbf{0}\). By extensionality, for each row \(i\), \((H\mathbf{0})_i = \sum _j H_{ij} \cdot 0 = 0\). Thus \(H\mathbf{0} = 0\).
A codeword has zero syndrome: if \(v\) is a codeword, then \(\operatorname {syndrome}(v) = 0\).
This follows directly from the hypothesis \(h\), since being a codeword means \(Hv = 0\), which is exactly the syndrome.
The row support of row \(j\) of a binary matrix \(H \in \mathbb {F}_2^{r \times n}\) is the set of column indices where the entry is \(1\):
The column support of column \(i\) of a binary matrix \(H \in \mathbb {F}_2^{r \times n}\) is the set of row indices where the entry is \(1\):
Every element of \(\mathbb {Z}/2\mathbb {Z}\) is either \(0\) or \(1\).
We perform case analysis on \(x \in \mathbb {Z}/2\mathbb {Z}\). Since \(\mathbb {Z}/2\mathbb {Z}\) has exactly two elements, \(x\) is either \(0\) or \(1\). In the first case, \(x = 0\) by reflexivity. In the second case, \(x = 1\) by reflexivity.
The row support of row \(j\) is empty if and only if all entries in that row are zero:
We prove both directions. For the forward direction, assume the support is empty. Suppose for contradiction that \(H_{jk} \neq 0\) for some \(k\). By the lemma that every element of \(\mathbb {Z}/2\mathbb {Z}\) is \(0\) or \(1\), either \(H_{jk} = 0\) (contradicting our assumption) or \(H_{jk} = 1\). But if \(H_{jk} = 1\), then \(k\) would be in the support, contradicting emptiness.
For the reverse direction, assume all entries are zero. Then for any \(k\) with \(H_{jk} = 1\), we have \(H_{jk} = 0\) by assumption, which gives \(0 = 1\), a contradiction in \(\mathbb {Z}/2\mathbb {Z}\) (verified by decision procedure).
The CSS condition for matrices \(H_X \in \mathbb {F}_2^{r_X \times n}\) and \(H_Z \in \mathbb {F}_2^{r_Z \times n}\) is:
This ensures that X-type and Z-type stabilizers commute.
The CSS condition is equivalent to each row of \(H_X\) being orthogonal to each row of \(H_Z\):
For the forward direction, assume \(H_X H_Z^T = 0\). Taking the \((i,j)\)-entry of both sides, we have \((H_X H_Z^T)_{ij} = 0\). By the definition of matrix multiplication and transpose, this equals \(\sum _k H_X(i,k) \cdot H_Z(j,k) = 0\).
For the reverse direction, assume the orthogonality condition. By matrix extensionality, we show \((H_X H_Z^T)_{ij} = 0\) for all \(i, j\). Expanding the matrix product with transpose, this is exactly the assumed orthogonality condition.
If the CSS condition holds, then each row of \(H_X\) is orthogonal to each row of \(H_Z\):
Rewriting the CSS condition using the equivalence theorem, the result follows directly.
A CSS (Calderbank-Shor-Steane) code on \(n\) physical qubits with \(r_X\) X-type generators and \(r_Z\) Z-type generators consists of:
An X-type parity check matrix \(H_X \in \mathbb {F}_2^{r_X \times n}\)
A Z-type parity check matrix \(H_Z \in \mathbb {F}_2^{r_Z \times n}\)
The CSS condition: \(H_X H_Z^T = 0\)
The X-type stabilizer generator from row \(j\) of \(H_X\) is a pure X-type operator:
with X-support equal to \(\operatorname {rowSupport}(H_X, j)\), Z-support empty, and phase \(+1\).
The Z-type stabilizer generator from row \(j\) of \(H_Z\) is a pure Z-type operator:
with X-support empty, Z-support equal to \(\operatorname {rowSupport}(H_Z, j)\), and phase \(+1\).
Any two X-type stabilizer generators commute.
Unfolding the definition of commutation and X generators, the overlap \(|\operatorname {supp}_X(S_i) \cap \operatorname {supp}_Z(S_j)| + |\operatorname {supp}_Z(S_i) \cap \operatorname {supp}_X(S_j)|\) involves intersections with empty sets (since both generators have empty Z-support). By simplification, the intersection with an empty set is empty, so the cardinality is \(0\), and \(0 \mod 2 = 0\).
Any two Z-type stabilizer generators commute.
Unfolding the definition of commutation and Z generators, both generators have empty X-support. The overlap involves intersections with empty sets, giving cardinality \(0\), and \(0 \mod 2 = 0\).
For a CSS code, X-type and Z-type stabilizer generators commute. Specifically, for X generator \(i\) and Z generator \(j\):
Unfolding the commutation condition for X and Z generators, we need to show \(|\operatorname {rowSupport}(H_X, i) \cap \operatorname {rowSupport}(H_Z, j)| \equiv 0 \pmod{2}\).
From the CSS condition, we have \(\sum _k H_X(i,k) \cdot H_Z(j,k) = 0\) in \(\mathbb {F}_2\).
Let \(S = \operatorname {rowSupport}(H_X, i) \cap \operatorname {rowSupport}(H_Z, j)\).
First, we establish that for \(k \in S\), we have \(H_X(i,k) \cdot H_Z(j,k) = 1\), since both entries equal \(1\) by definition of the row supports.
Second, for \(k \notin S\), we have \(H_X(i,k) \cdot H_Z(j,k) = 0\). This follows by case analysis: either \(H_X(i,k) = 0\) (giving \(0 \cdot H_Z(j,k) = 0\)), or \(H_X(i,k) = 1\) and \(H_Z(j,k) \neq 1\). In the latter case, since every element of \(\mathbb {Z}/2\mathbb {Z}\) is \(0\) or \(1\), we have \(H_Z(j,k) = 0\), giving \(1 \cdot 0 = 0\).
Thus the sum splits as \(\sum _k H_X(i,k) \cdot H_Z(j,k) = \sum _{k \in S} 1 = |S|\) in \(\mathbb {F}_2\).
Since the CSS condition gives \(\sum _k H_X(i,k) \cdot H_Z(j,k) = 0\), we have \(|S| \equiv 0 \pmod{2}\).
Z-type and X-type generators commute (by symmetry of the commutationrelation).
By the symmetry of the commutation relation for stabilizer checks, this follows directly from the theorem that X and Z generators commute.
The number of physical qubits in a CSS code is \(n\).
The number of X-type generators in a CSS code is \(r_X\).
The number of Z-type generators in a CSS code is \(r_Z\).
The total number of stabilizer generators in a CSS code is \(r_X + r_Z\).
The weight of X-type generator \(j\) is the weight of the corresponding stabilizer check.
The weight of Z-type generator \(j\) is the weight of the corresponding stabilizer check.
The weight of X generator \(j\) equals the cardinality of the row support:
Unfolding the definitions of X generator weight, stabilizer check weight, and X generator, the weight is the cardinality of the union of X and Z supports. Since the Z support is empty, by simplification the union with empty is just the X support, which equals the row support.
The weight of Z generator \(j\) equals the cardinality of the row support:
Unfolding the definitions, the weight is the cardinality of the union of X and Z supports. Since the X support is empty, by simplification the union with empty is just the Z support, which equals the row support.
A vector \(v \in \mathbb {F}_2^n\) is an X-type logical operator for a CSS code if:
\(v \in \ker (H_Z)\), i.e., \(H_Z v = 0\) (satisfies Z parity checks)
\(v\) is not in the dual of \(C_Z\), i.e., \(v\) has nontrivial X-logical action
A vector \(v \in \mathbb {F}_2^n\) is a Z-type logical operator for a CSS code if:
\(v \in \ker (H_X)\), i.e., \(H_X v = 0\) (satisfies X parity checks)
\(v\) is not in the dual of \(C_X\), i.e., \(v\) has nontrivial Z-logical action
The minimum X-distance of a CSS code is the infimum of the Hamming weights of all X-type logical operators:
The minimum Z-distance of a CSS code is the infimum of the Hamming weights of all Z-type logical operators:
The code distance of a CSS code is the minimum of the X-distance and Z-distance:
The CSS condition is symmetric: \(H_X H_Z^T = 0\) if and only if \(H_Z H_X^T = 0\).
For the forward direction, assume \(H_X H_Z^T = 0\). We show \(H_Z H_X^T = 0\) by matrix extensionality. For any \((i, j)\), the \((j, i)\)-entry of \(H_X H_Z^T\) is zero, which gives \(\sum _k H_X(j,k) \cdot H_Z(i,k) = 0\). Using commutativity of multiplication in \(\mathbb {F}_2\) (via ring arithmetic), this equals \(\sum _k H_Z(i,k) \cdot H_X(j,k)\), which is the \((i,j)\)-entry of \(H_Z H_X^T\).
The reverse direction is symmetric.
The row support of any row of the zero matrix is empty.
By definition, the row support filters positions where \(H_{ji} = 1\). For the zero matrix, all entries are \(0\). The filter is empty since \(0 \neq 1\) (verified by decision procedure).
The CSS condition holds trivially for zero matrices: \(0 \cdot 0^T = 0\).
Unfolding the CSS condition, we need \(0 \cdot 0^T = 0\). By the property that zero times any matrix is zero, this holds.
If \(H_X = 0\), then all X generators have empty X-support.
Simplifying the X generator definition with \(H_X = 0\), the X-support equals \(\operatorname {rowSupport}(0, j) = \emptyset \) by the row support zero theorem.
Any two stabilizer generators (X or Z type) of a CSS code commute.
We perform case analysis on whether each generator is X-type or Z-type.
Case 1: Both are X generators. By the theorem that X generators commute, \(s\) and \(t\) commute.
Case 2: \(s\) is an X generator and \(t\) is a Z generator. By the XZ commutation theorem, they commute.
Case 3: \(s\) is a Z generator and \(t\) is an X generator. By the ZX commutation theorem (symmetry), they commute.
Case 4: Both are Z generators. By the theorem that Z generators commute, they commute.
The symplectic inner product of two Pauli operators \(P\) and \(Q\) on \(n\) qubits, computed from their supports, is defined as:
This measures the “non-commutativity” between \(P\) and \(Q\).
For Pauli operators \(P = \prod _v X_v^{a_v} Z_v^{b_v}\) and \(Q = \prod _v X_v^{c_v} Z_v^{d_v}\), the symplectic inner product computed directly from exponent functions is:
where \(a, b, c, d : \mathrm{Fin}(n) \to \mathbb {Z}/2\mathbb {Z}\).
The contribution from site \(i\) to the symplectic form counts how many of the following conditions hold:
\(P\) has an \(X\) component at site \(i\) and \(Q\) has a \(Z\) component at site \(i\)
\(P\) has a \(Z\) component at site \(i\) and \(Q\) has an \(X\) component at site \(i\)
Formally:
Two single-qubit Pauli operators \(P\) and \(Q\) anticommute (i.e., \(\mathrm{singleCommute}(P, Q) = \mathrm{false}\)) if and only if they form one of the following pairs:
\((P, Q) = (X, Z)\) or \((Z, X)\)
\((P, Q) = (X, Y)\) or \((Y, X)\)
\((P, Q) = (Z, Y)\) or \((Y, Z)\)
By exhaustive case analysis on all possible combinations of single-qubit Pauli operators \(P\) and \(Q\), applying simplification using the definition of \(\mathrm{singleCommute}\).
The single-qubit Pauli operators \(X\) and \(Z\) anticommute: \(\mathrm{singleCommute}(X, Z) = \mathrm{false}\).
This holds by reflexivity (definitional equality).
The single-qubit Pauli operators \(Z\) and \(X\) anticommute: \(\mathrm{singleCommute}(Z, X) = \mathrm{false}\).
This holds by reflexivity (definitional equality).
The single-qubit Pauli operators \(X\) and \(Y\) anticommute: \(\mathrm{singleCommute}(X, Y) = \mathrm{false}\).
This holds by reflexivity (definitional equality).
The single-qubit Pauli operators \(Y\) and \(X\) anticommute: \(\mathrm{singleCommute}(Y, X) = \mathrm{false}\).
This holds by reflexivity (definitional equality).
The single-qubit Pauli operators \(Z\) and \(Y\) anticommute: \(\mathrm{singleCommute}(Z, Y) = \mathrm{false}\).
This holds by reflexivity (definitional equality).
The single-qubit Pauli operators \(Y\) and \(Z\) anticommute: \(\mathrm{singleCommute}(Y, Z) = \mathrm{false}\).
This holds by reflexivity (definitional equality).
The anticommuting condition at a site \(i\) is equivalent to the symplectic contribution being odd. That is, for Pauli strings \(P\) and \(Q\) and site \(i\):
Unfolding the definition of \(\mathrm{siteSymplecticContrib}\), we perform case analysis on \(P_i\) and \(Q_i\). For each combination of Pauli operators, we simplify using the definitions of \(\mathrm{singleCommute}\), \(\mathrm{hasX}\), and \(\mathrm{hasZ}\) to verify the equivalence.
For Pauli strings \(P\) and \(Q\) on \(n\) qubits:
Unfolding the definition of \(\mathrm{anticommutingOverlap}\), we establish that:
We first show that for each \(i\):
This follows from Lemma 2474: we consider whether \(\mathrm{singleCommute}(P_i, Q_i) = \mathrm{false}\). If true, then by the lemma, \(\mathrm{siteSymplecticContrib}(P, Q, i) \mod 2 = 1\). If false, then \(\mathrm{siteSymplecticContrib}(P, Q, i) \mod 2 \neq 1\), and since this value is bounded by \(2\), it must equal \(0\).
We then express the cardinality as a sum of indicator functions and rewrite using the established equality. Finally, we apply the fact that \((\sum _i a_i \mod 2) \mod 2 = (\sum _i a_i) \mod 2\).
The sum of symplectic contributions equals the cross-support overlaps:
Expanding the definition of \(\mathrm{siteSymplecticContrib}\) and distributing the sum:
For the first sum, we show it equals \((S_X(P) \cap S_Z(Q)).\mathrm{card}\) by rewriting the sum of indicators as the cardinality of a filtered set, then showing this filtered set equals \(S_X(P) \cap S_Z(Q)\) by extensionality using the definitions of support.
For the second sum, we similarly show it equals \((S_Z(P) \cap S_X(Q)).\mathrm{card}\) using the same technique.
Two Pauli strings \(P\) and \(Q\) commute if and only if their \(X\)-\(Z\) support overlaps sum to an even number:
This theorem connects the operator-theoretic definition of commutation (based on single-qubit \(X\)-\(Z\) anticommutation) to the combinatorial formula.
Two Pauli operators \(P\) and \(Q\) commute (in the sense of operator algebra) if and only if their symplectic inner product is zero:
Equivalently:
This is derived from the fundamental fact that \(X\) and \(Z\) anticommute on a single qubit, and the overall commutation depends on the parity of such anticommutations.
Unfolding the definitions of \(\mathrm{StabilizerCheck.commutes}\) and \(\mathrm{symplecticInnerProduct}\), the result follows by reflexivity (definitional equality).
The commutation condition expressed using support overlap directly:
This holds by reflexivity (definitional equality).
The symplectic inner product is symmetric: \(\omega (P, Q) = \omega (Q, P)\).
Unfolding the definition of \(\mathrm{symplecticInnerProduct}\), we use commutativity of set intersection:
By commutativity of addition, we obtain:
and hence \(\omega (P, Q) = \omega (Q, P)\).
The symplectic inner product of the identity with any operator is zero: \(\omega (I, P) = 0\).
Unfolding the definitions of \(\mathrm{symplecticInnerProduct}\) and \(\mathrm{StabilizerCheck.identity}\), since the identity has empty \(X\)-support and empty \(Z\)-support, the intersections \(\emptyset \cap P.S_Z\) and \(\emptyset \cap P.S_X\) are both empty. Thus the sum of cardinalities is \(0 + 0 = 0\), and \(0 \mod 2 = 0\).
The symplectic inner product of any operator with the identity is zero: \(\omega (P, I) = 0\).
The symplectic inner product of any Pauli operator with itself is zero: \(\omega (P, P) = 0\).
Unfolding the definition of \(\mathrm{symplecticInnerProduct}\), we observe that:
by commutativity of intersection (\(P.S_Z \cap P.S_X = P.S_X \cap P.S_Z\)). Since \(2k \mod 2 = 0\) for any \(k\), the result follows.
Every Pauli operator commutes with itself: \([P, P] = 0\).
The identity operator commutes with every Pauli operator: \([I, P] = 0\) for all \(P\).
The symplectic inner product is additive in the first argument modulo 2:
Unfolding the definitions of \(\mathrm{symplecticInnerProduct}\) and \(\mathrm{StabilizerCheck.mul}\), we use the fact that for symmetric difference:
and similarly for the \(Z\)-supports. The result follows by integer arithmetic.
If \(A\) commutes with \(D\) and \(B\) commutes with \(D\), then \(A \cdot B\) commutes with \(D\).
The commutation relation is symmetric: \(P\) commutes with \(Q\) if and only if \(Q\) commutes with \(P\).
This follows directly from the symmetry of \(\mathrm{StabilizerCheck.commutes}\).
The identity operator commutes with any operator \(P\): \(\mathrm{StabilizerCheck.commutes}(I, P)\).
This follows directly from \(\mathrm{StabilizerCheck.identity\_ commutes\_ all}\).
Any operator \(P\) commutes with the identity: \(\mathrm{StabilizerCheck.commutes}(P, I)\).
Every operator commutes with itself: \(\mathrm{StabilizerCheck.commutes}(P, P)\).
This follows directly from \(\mathrm{StabilizerCheck.self\_ commutes}\).
Two Pauli operators \(P\) and \(Q\) anticommute if their symplectic inner product equals 1:
\(P\) and \(Q\) anticommute if and only if they do not commute:
Unfolding the definition of \(\mathrm{anticommutes}\) and applying Theorem 2478, we need to show:
For the forward direction, if \(\omega (P, Q) = 1\), then clearly \(\omega (P, Q) \neq 0\).
For the backward direction, if \(\omega (P, Q) \neq 0\), we note that \(\omega (P, Q)\) is defined as a value modulo 2, so \(\omega (P, Q) \in \{ 0, 1\} \). Since \(\omega (P, Q) \neq 0\) and \(\omega (P, Q) {\lt} 2\), we must have \(\omega (P, Q) = 1\).
The anticommutation relation is symmetric: \(\mathrm{anticommutes}(P, Q) \iff \mathrm{anticommutes}(Q, P)\).
Unfolding the definition of \(\mathrm{anticommutes}\) and applying the symmetry of the symplectic inner product (Theorem 2480):
A Pauli string \(P\) can be converted to a stabilizer check with trivial phase:
The conversion preserves \(X\)-support: \((\mathrm{pauliStringToCheck}(P)).S_X = \mathrm{supportX}(P)\).
This holds by reflexivity (definitional equality).
The conversion preserves \(Z\)-support: \((\mathrm{pauliStringToCheck}(P)).S_Z = \mathrm{supportZ}(P)\).
This holds by reflexivity (definitional equality).
Commutation of Pauli strings can be computed via stabilizer check commutation:
This holds by reflexivity (definitional equality).
The stabilizer check commutation matches the Pauli string commutation:
The symplectic inner product is at most 1: \(\omega (P, Q) \leq 1\).
Unfolding the definition of \(\mathrm{symplecticInnerProduct}\), the result is computed modulo 2. Since for any \(n\), we have \(n \mod 2 {\lt} 2\), and hence \(\omega (P, Q) \in \{ 0, 1\} \), the bound \(\omega (P, Q) \leq 1\) follows.
If \(P\) has no \(X\)-support and no \(Z\)-support, then \(P\) commutes with any \(Q\).
Unfolding the definition of \(\mathrm{StabilizerCheck.commutes}\), we substitute \(P.S_X = \emptyset \) and \(P.S_Z = \emptyset \). The intersections \(\emptyset \cap Q.S_Z\) and \(\emptyset \cap Q.S_X\) are both empty, so the sum of cardinalities is \(0 + 0 = 0\), and \(0 \mod 2 = 0\).
An \(X\)-only operator \(P\) (with \(P.S_Z = \emptyset \)) commutes with a \(Z\)-only operator \(Q\) (with \(Q.S_X = \emptyset \)) when their overlap \(|P.S_X \cap Q.S_Z|\) is even.
Unfolding the definition of \(\mathrm{StabilizerCheck.commutes}\), we substitute \(P.S_Z = \emptyset \) and \(Q.S_X = \emptyset \). Then:
The condition becomes \((|P.S_X \cap Q.S_Z|) \mod 2 = 0\), which holds by the assumption that \(|P.S_X \cap Q.S_Z|\) is even.
The overlap count measures the degree of non-commutativity between two Pauli operators:
\(P\) and \(Q\) commute if and only if their overlap count is even:
Unfolding the definitions of \(\mathrm{StabilizerCheck.commutes}\) and \(\mathrm{overlapCount}\), and using the characterization of evenness via \(n \mod 2 = 0\), the equivalence follows directly.
The overlap count is bounded by the total support size of \(P\):
Unfolding the definition of \(\mathrm{overlapCount}\), we use the fact that intersection is a subset of each operand:
Adding these inequalities yields the result.
A cycle circuit in a graph \(G\) with vertex set \(V\) is a structure consisting of:
A base vertex \(\mathtt{base} \in V\)
A walk \(\mathtt{walk}\) from \(\mathtt{base}\) to \(\mathtt{base}\) in \(G\)
A proof that \(\mathtt{walk}\) is a circuit (closed trail)
This directly connects to the mathematical definition of a cycle as a closed trail, from which we can prove (not assume) the even-degree property.
For any circuit in a graph \(G\) and any vertex \(x \in V\), the count of edges containing \(x\) in the circuit is even:
Since the circuit has the trail property, we apply Mathlib’s key theorem about trail edge counts (IsTrail.even_countP_edges_iff). For a trail from \(u\) to \(v\), the count of edges containing \(x\) is even if and only if \(u \neq v \Rightarrow x \neq u \land x \neq v\). For a closed walk where \(\mathtt{base} = \mathtt{base}\), the antecedent is false (since \(\mathtt{base} \neq \mathtt{base}\) is absurd), so the count is always even. Formally, assuming \(h_{ne} : \mathtt{base} \neq \mathtt{base}\), we derive a contradiction from reflexivity.
For any circuit in a graph \(G\) and any vertex \(x\), the length of the filtered list of edges containing \(x\) is even:
By Theorem 2507, the count of edges containing \(x\) is even. Since \(\texttt{countP} = \texttt{length} \circ \texttt{filter}\) by List.countP_eq_length_filter, the result follows.
A flux configuration with circuits for a stabilizer code \(C\) and X-type logical operator \(L\) is a structure consisting of:
The underlying gauging graph \(\mathtt{graph}\)
An index type \(\mathtt{CycleIdx}\) for cycles in the generating set
Finiteness and decidable equality instances for \(\mathtt{CycleIdx}\)
A function \(\mathtt{cycles} : \mathtt{CycleIdx} \to \text{CycleCircuit}(\mathtt{graph})\) assigning each cycle index to a circuit in the graph
The key difference from the original flux configuration is that cycles are represented as actual circuits, and the even-degree property is proven rather than assumed.
The edge finset of a circuit is the set of edges in the circuit’s walk, converted to a finite set:
For a flux configuration with circuits \(F\) and cycle index \(c\), the cycle edges is the finite set of edges in the corresponding circuit:
For any flux configuration with circuits \(F\), cycle index \(c\), and vertex \(v\), the cardinality of edges in cycle \(c\) that are incident to \(v\) is even:
This is the key mathematical content that was previously assumed as an axiom. Now it is proven from the circuit definition of cycles.
Let \(\mathtt{circuit} = F.\texttt{cycles}(c)\). By Theorem 2507, the count of edges containing \(v\) in the walk is even. Converting this count to filter length via List.countP_eq_length_filter, we have that the filtered list has even length.
Since the walk is a trail, the edges list has no duplicates (IsTrail.edges_nodup). The filtered list inherits this property. For lists without duplicates, the finset cardinality equals the list length. Therefore, the filter over the finset has even cardinality.
For a flux configuration with circuits \(F\), vertex \(v\), and cycle index \(c\), the incident cycle edges is the set of edges in cycle \(c\) that are incident to vertex \(v\):
The symplectic form between a Gauss law operator \(A_v\) and a flux operator \(B_c\) is the count of edges that are both incident to \(v\) and in cycle \(c\):
The symplectic form equals the cardinality of incident cycle edges:
This holds by definition (reflexivity).
(Proposition 3) For any flux configuration with circuits \(F\), vertex \(v\), and cycle index \(c\), the Gauss law operator \(A_v\) commutes with the flux operator \(B_c\):
Unfolding the definitions, the symplectic form equals the cardinality of incident cycle edges. By Theorem 2512, this cardinality is even. Therefore, by Nat.even_iff, the symplectic form is congruent to \(0\) modulo \(2\).
For any flux configuration with circuits \(F\), vertex \(v\), and cycle index \(c\), the symplectic form is even:
Unfolding the definitions, this follows directly from Theorem 2512.
For any flux configuration with circuits \(F\), all Gauss law and flux operator pairs commute:
Let \(v\) be an arbitrary vertex and \(c\) an arbitrary cycle index. The result follows directly from Theorem 2516.
For any vertex \(v\), it commutes with all flux operators:
Let \(c\) be an arbitrary cycle index. The result follows directly from Theorem 2516.
For any cycle \(c\), all Gauss law operators commute with \(B_c\):
Let \(v\) be an arbitrary vertex. The result follows directly from Theorem 2516.
The symplectic form as a \(\mathbb {Z}/2\mathbb {Z}\) value:
The symplectic form in \(\mathbb {Z}/2\mathbb {Z}\) equals zero:
Unfolding the definition, by Theorem 2516 we have \(\omega (A_v, B_c) \equiv 0 \pmod{2}\). This implies \(2 \mid \omega (A_v, B_c)\) by Nat.dvd_of_mod_eq_zero. By ZMod.natCast_eq_zero_iff, the natural number cast to \(\mathbb {Z}/2\mathbb {Z}\) equals zero.
Two divides the symplectic form:
By Theorem 2517, the symplectic form is even. By Even.two_dvd, two divides even numbers.
The symplectic form divided by 2 is well-defined:
By Theorem 2523, \(2 \mid \omega (A_v, B_c)\). By Nat.eq_mul_of_div_eq_right, when a divisor divides a number, the number equals the divisor times the quotient.
Summing symplectic forms over vertices gives an even total:
We apply Finset.even_sum. For each vertex \(v\) in the universal finite set, by Theorem 2517, \(\omega (A_v, B_c)\) is even. A sum of even numbers is even.
If a vertex \(v\) is not in any edge of cycle \(c\), then the incident cycle edges set is empty:
Unfolding the definition of incident cycle edges, we use Finset.filter_eq_empty_iff. For any edge \(e\) in the cycle edges, by hypothesis \(v \notin e\), so the filter predicate is never satisfied.
When edge overlap is empty, the symplectic form is 0:
Unfolding the definition of the symplectic form, if the incident cycle edges set is empty, then its cardinality is 0 by Finset.card_empty.
The incident cycle edges is a subset of the cycle edges:
Unfolding the definition of incident cycle edges, this follows from Finset.filter_subset.
Elements of the incident cycle edges set are incident to \(v\):
Unfolding the definition of incident cycle edges at the hypothesis, by Finset.mem_filter, membership in the filtered set implies the predicate holds, i.e., \(v \in e\).
Commuting operators can be measured simultaneously:
This follows directly from Theorem 2516.
All Gauss law operators commute with all flux operators:
A flux configuration with circuits can be converted to a standard flux configuration. The structure is:
\(\mathtt{graph} = F.\mathtt{graph}\)
\(\mathtt{CycleIdx} = F.\mathtt{CycleIdx}\)
\(\mathtt{cycleEdges} = F.\texttt{cycleEdges}\)
\(\mathtt{cycles\_ subset}\): Edges in the walk are actual graph edges
\(\mathtt{cycles\_ valid}\): This is now proven from the circuit property via Theorem 2512
The conversion preserves the cycle edges:
This holds by definition (reflexivity).
The conversion preserves commutation:
This follows from the original theorem gaussLaw_flux_commute from the flux operators definition, applied to the converted configuration.
A simplification lemma reducing commutation check to the proven even-degree property:
This follows directly from Theorem 2516.
A gauge operator on \(n\) qubits is a Pauli operator, represented using the same binary vector encoding as stabilizer checks. In a subsystem code, gauge operators form a (generally non-abelian) group.
Formally, a gauge operator is an abbreviation for a stabilizer check: \(\mathrm{GaugeOperator}(n) := \mathrm{StabilizerCheck}(n)\).
The identity gauge operator on \(n\) qubits is the identity Pauli operator.
Two gauge operators \(g_1\) and \(g_2\) commute if their symplectic product is even, i.e., if they commute as stabilizer checks.
The product of two gauge operators \(g_1\) and \(g_2\) is defined componentwise via the stabilizer check multiplication.
The weight of a gauge operator \(g\) is defined as the weight of the corresponding stabilizer check, counting the number of non-identity Pauli terms.
For gauge operators \(g_1\) and \(g_2\), commutation is symmetric:
This follows directly from the symmetry of the stabilizer check commutation relation.
Every gauge operator commutes with itself: for any gauge operator \(g\),
This follows directly from the self-commutation property of stabilizer checks.
The identity gauge operator commutes with any gauge operator \(g\):
This follows from the fact that the identity stabilizer check commutes with all checks.
A gauge operator \(g\) is in the center of a gauge group generated by \(\{ g_1, \ldots , g_m\} \) if it commutes with all generators:
The stabilizer group \(S = Z(G) \cap G\) consists of exactly these center elements.
If \(g_1\) and \(g_2\) are both in the center of a gauge group, then their product \(g_1 \cdot g_2\) is also in the center.
Let \(i\) be arbitrary. We need to show that \(g_1 \cdot g_2\) commutes with the \(i\)-th generator. Unfolding the definitions of commutation and multiplication, this follows from the fact that if \(g_1\) commutes with the generator and \(g_2\) commutes with the generator, then their product also commutes with the generator.
The identity gauge operator is always in the center of any gauge group.
Let \(i\) be arbitrary. The identity commutes with the \(i\)-th generator by the theorem that identity commutes with all gauge operators.
A subsystem code on \(n\) qubits is a structure consisting of:
\(m_{\text{Gauge}}\) gauge generators: a function \(\mathrm{gaugeGenerators} : \mathrm{Fin}(m_{\text{Gauge}}) \to \mathrm{GaugeOperator}(n)\)
\(m_{\text{Stab}}\) stabilizer generators: a function \(\mathrm{stabilizerGenerators} : \mathrm{Fin}(m_{\text{Stab}}) \to \mathrm{GaugeOperator}(n)\)
A proof that each stabilizer generator is in the center of the gauge group
A proof that all stabilizer generators mutually commute
The gauge group \(G\) is generated by the gauge generators. The stabilizer group \(S = Z(G) \cap G\) is the center of \(G\) (which is abelian). The code space is the simultaneous \(+1\) eigenspace of all stabilizers. Gauge qubits are additional degrees of freedom not used for logical information.
The code space factors as \(\mathcal{C} = \mathcal{C}_{\text{logical}} \otimes \mathcal{C}_{\text{gauge}}\).
The number of physical qubits in a subsystem code \(C\) is defined as \(n\).
The number of gauge generators in a subsystem code \(C\) is defined as \(m_{\text{Gauge}}\).
The number of stabilizer generators in a subsystem code \(C\) is defined as \(m_{\text{Stab}}\).
For a subsystem code \(C\) and index \(i \in \mathrm{Fin}(m_{\text{Gauge}})\), the \(i\)-th gauge generator is \(C.\mathrm{gaugeGenerators}(i)\).
For a subsystem code \(C\) and index \(j \in \mathrm{Fin}(m_{\text{Stab}})\), the \(j\)-th stabilizer generator is \(C.\mathrm{stabilizerGenerators}(j)\).
For a subsystem code \(C\), any stabilizer generator commutes with any gauge generator:
This follows directly from the condition that stabilizer generators are in the center of the gauge group.
For a subsystem code \(C\), any two stabilizer generators commute:
This follows directly from the stabilizers_commute field of the subsystem code structure.
A gauge fixing for a subsystem code consists of:
The subsystem code being fixed
Measurement outcomes for the “independent” gauge operators (those not in the stabilizer): a function \(\mathrm{outcomes} : \mathrm{Fin}(m_{\text{Gauge}} - m_{\text{Stab}}) \to \mathrm{Bool}\)
When we measure gauge operators, we collapse \(\mathcal{C}_{\text{gauge}}\) to a definite state, converting the subsystem code to a stabilizer code.
The number of gauge qubits (degrees of freedom in \(\mathcal{C}_{\text{gauge}}\)) is defined as:
This equals \((m_{\text{Gauge}} - m_{\text{Stab}}) / 2\) when all gauge operators pair up properly.
After gauge fixing, the effective number of stabilizer generators increases to \(m_{\text{Gauge}}\) (since all gauge generators become stabilizers after fixing).
The code space dimension exponent of a subsystem code is:
The code space dimension is \(\dim (\mathcal{C}) = 2^{n - m_{\text{Stab}}}\), which accounts for both logical and gauge qubits.
The logical qubit dimension exponent is:
This gives \(\dim (\mathcal{C}_{\text{logical}}) = 2^{n - m_{\text{Gauge}}}\).
The gauge qubit dimension exponent is:
This gives \(\dim (\mathcal{C}_{\text{gauge}}) = 2^{(m_{\text{Gauge}} - m_{\text{Stab}})/2}\).
For a subsystem code with \(m_{\text{Stab}} \le m_{\text{Gauge}} \le n\), the code space dimension satisfies:
That is, \(\dim (\mathcal{C}) = \dim (\mathcal{C}_{\text{logical}}) \times \dim (\mathcal{C}_{\text{gauge}})^2\).
By simplification using the definitions, we have:
This follows by integer arithmetic (omega tactic).
The deformed code subsystem condition specifies when a deformed code becomes a subsystem code. It consists of:
\(|E|\): the number of edges in the gauging graph
\(|V|\): the number of vertices in the gauging graph
The condition \(|E| {\gt} |V| - 1\)
When this condition holds, there are gauge degrees of freedom on the edge qubits.
The number of gauge degrees of freedom from edge qubits is:
When the deformed code subsystem condition holds, the number of edge gauge qubits is at least 1:
Unfolding the definition of \(\mathrm{numEdgeGaugeQubits}\), we have \(\mathrm{numEdgeGaugeQubits} = |E| - (|V| - 1)\). From the edge-vertex condition \(|E| {\gt} |V| - 1\), by integer arithmetic (omega), we conclude \(|E| - (|V| - 1) \ge 1\).
When the deformed code subsystem condition holds, we have:
From the edge-vertex condition \(|E| {\gt} |V| - 1\), by integer arithmetic (omega), we conclude \(|E| \ge |V|\).
A stabilizer code can be viewed as a subsystem code with no gauge qubits. Given a stabilizer code \(C\) on \(n\) qubits encoding \(k\) logical qubits:
The gauge generators are the stabilizer checks: \(\mathrm{gaugeGenerators} := C.\mathrm{checks}\)
The stabilizer generators are also the checks: \(\mathrm{stabilizerGenerators} := C.\mathrm{checks}\)
Each stabilizer is in the center because all checks commute (from \(C.\mathrm{checks\_ commute}\))
Stabilizers mutually commute by the same property
This yields a subsystem code with \(m_{\text{Gauge}} = m_{\text{Stab}} = n - k\).
A subsystem code is effectively a stabilizer code if \(m_{\text{Gauge}} = m_{\text{Stab}}\), i.e., the gauge group equals the stabilizer group.
For a subsystem code with \(m_{\text{Gauge}} = m_{\text{Stab}} = m\), the gauge dimension exponent is zero:
By simplification using the definition, we have:
A CSS subsystem code on \(n\) qubits is a subsystem code where gauge generators are either purely X-type or purely Z-type. It consists of:
\(m_X\) X-type gauge generators: \(\mathrm{xGaugeGenerators} : \mathrm{Fin}(m_X) \to \mathrm{GaugeOperator}(n)\)
\(m_Z\) Z-type gauge generators: \(\mathrm{zGaugeGenerators} : \mathrm{Fin}(m_Z) \to \mathrm{GaugeOperator}(n)\)
\(m_{\text{Stab}}\) stabilizer generators
X generators are pure X-type: \(\forall i,\, (\mathrm{xGaugeGenerators}(i)).\mathrm{supportZ} = \emptyset \)
Z generators are pure Z-type: \(\forall j,\, (\mathrm{zGaugeGenerators}(j)).\mathrm{supportX} = \emptyset \)
X generators commute with each other
Z generators commute with each other
Stabilizers commute with all X and Z generators
Stabilizers mutually commute
The total number of gauge generators in a CSS subsystem code is \(m_X + m_Z\).
For a CSS subsystem code \(C\) and \(i \in \mathrm{Fin}(m_X)\):
This follows directly from the \(\mathrm{xGenerators\_ pure}\) field of the CSS subsystem code structure.
For a CSS subsystem code \(C\) and \(j \in \mathrm{Fin}(m_Z)\):
This follows directly from the \(\mathrm{zGenerators\_ pure}\) field of the CSS subsystem code structure.
For a CSS subsystem code \(C\) and \(i_1, i_2 \in \mathrm{Fin}(m_X)\):
This follows directly from the \(\mathrm{xGenerators\_ commute}\) field of the CSS subsystem code structure.
For a CSS subsystem code \(C\) and \(j_1, j_2 \in \mathrm{Fin}(m_Z)\):
This follows directly from the \(\mathrm{zGenerators\_ commute}\) field of the CSS subsystem code structure.
For a subsystem code \(C\) on \(n\) qubits:
This holds by reflexivity (definitional equality).
For a subsystem code \(C\) with \(m_{\text{Gauge}}\) gauge generators:
This holds by reflexivity (definitional equality).
For a subsystem code \(C\) with \(m_{\text{Stab}}\) stabilizer generators:
This holds by reflexivity (definitional equality).
For a stabilizer code \(C\) converted to a subsystem code:
By simplification using the definition:
For a gauge fixing \(gf\):
This holds by reflexivity (definitional equality).
For \(|E|\) edges and \(|V| \ge 1\) vertices:
This condition is equivalent to the graph having a cycle.
This equivalence follows by integer arithmetic (omega tactic), using the hypothesis \(|V| \ge 1\).
For any \(n\) and \(m_{\text{Stab}}\):
We construct a witness subsystem code where both gauge and stabilizer generators are the identity operator. By the theorem that gauge dimension is zero when effectively a stabilizer (i.e., when \(m_{\text{Gauge}} = m_{\text{Stab}}\)), we obtain the result. The construction uses the facts that identity commutes with all operators and every operator commutes with itself.
[Algorithm Correctness]
Algorithm 1 (Gauging measurement procedure) produces the correct post-measurement state up to a byproduct operator \(X_V(c')\).
Byproduct determination: The byproduct \(c' \in C_0(G; \mathbb {Z}_2)\) is determined by the \(Z_e\) measurement outcomes \(\{ \omega _e\} \):
where \(z_e = \frac{1 - \omega _e}{2} \in \{ 0, 1\} \) encodes the measurement outcome.
Constructive determination: Given a spanning tree \(T\) of \(G\) rooted at \(v_0\):
For each vertex \(v \neq v_0\), let \(\gamma _v\) be the unique path in \(T\) from \(v_0\) to \(v\)
Set \(c'_v = \bigoplus _{e \in \gamma _v} z_e\) (parity of outcomes along path)
Set \(c'_{v_0} = 0\)
This gives \(\delta _0(c') = z\) because tree paths have the required boundary property.
The key insight is that:
The edge outcomes \(z\) determine a 1-chain
We need to find a 0-chain \(c'\) with \(\delta _0(c') = z\)
A spanning tree provides a constructive way to compute \(c'\)
Key constraint: \(z\) must be in the image of \(\delta _0\) (i.e., \(z\) sums to 0 on every cycle)
Under this constraint, the path parity construction gives \(\delta _0(c') = z\) for ALL edges
No proof needed for remarks.
The outcome encoding maps a measurement outcome \(\omega \in \mathbb {Z}_2\) to its encoded value \(z \in \mathbb {Z}_2\). In our representation where \(0\) represents \(+1\) and \(1\) represents \(-1\), the encoding is the identity function:
This corresponds to the formula \(z_e = \frac{1 - \omega _e}{2}\) with \(\omega _e \in \{ +1, -1\} \):
\(\omega _e = +1\) (encoded as 0) \(\mapsto z_e = \frac{1-1}{2} = 0\)
\(\omega _e = -1\) (encoded as 1) \(\mapsto z_e = \frac{1-(-1)}{2} = 1\)
For all \(\omega \in \mathbb {Z}_2\), \(\texttt{outcomeEncoding}(\omega ) = \omega \).
This holds by reflexivity, since the encoding is defined as the identity function.
For all \(\omega _1, \omega _2 \in \mathbb {Z}_2\):
This holds by reflexivity, since the encoding is the identity function which trivially preserves addition.
\(\texttt{outcomeEncoding}(0) = 0\).
This holds by reflexivity.
\(\texttt{outcomeEncoding}(1) = 1\).
This holds by reflexivity.
Let \(C\) be a stabilizer code with \(n\) physical qubits and \(k\) logical qubits, and let \(M\) be a measurement configuration for an \(X\)-type logical operator. A vertex chain \(c' : \texttt{VertexChain } M\) satisfies the byproduct equation with respect to an edge chain \(z : \texttt{EdgeChain } M\) if:
where \(\delta _0\) is the coboundary map from 0-chains to 1-chains.
A vertex chain \(c'\) satisfies the byproduct equation with edge chain \(z\) if and only if for all edges \(e\):
We prove both directions.
\((\Rightarrow )\): Assume \(\texttt{satisfiesByproductEquation } M\, c'\, z\) holds. Let \(e\) be arbitrary. By the definition of satisfying the byproduct equation, we have \(\delta _0(c') = z\). Applying function extensionality at \(e\), we get \(\delta _0(c')(e) = z(e)\).
\((\Leftarrow )\): Assume for all \(e\), \(\delta _0(c')(e) = z(e)\). By function extensionality, since the functions agree at every point, we have \(\delta _0(c') = z\), which is exactly the definition of \(\texttt{satisfiesByproductEquation } M\, c'\, z\).
For any 0-chain \(c\), there exists a \(z\) such that \(\delta _0(c) = z\). Specifically, \(c\) satisfies the byproduct equation with \(z = \delta _0(c)\).
This holds by reflexivity: \(\delta _0(c) = \delta _0(c)\).
A spanning tree for a measurement configuration \(M\) is a structure consisting of:
A parent function \(\texttt{parent} : M.\texttt{Vertex} \to M.\texttt{Vertex}\) giving the parent of each vertex (the root is its own parent)
A depth function \(\texttt{depth} : M.\texttt{Vertex} \to \mathbb {N}\) measuring distance from the root
An edge-to-parent function \(\texttt{edgeToParent} : M.\texttt{Vertex} \to \texttt{Sym2}(M.\texttt{Vertex})\) giving the edge connecting each vertex to its parent
satisfying:
\(\texttt{depth}(M.\texttt{root}) = 0\)
\(\texttt{parent}(M.\texttt{root}) = M.\texttt{root}\)
For all \(v \neq M.\texttt{root}\): \(0 {\lt} \texttt{depth}(v)\)
For all \(v \neq M.\texttt{root}\): \(\texttt{depth}(\texttt{parent}(v)) {\lt} \texttt{depth}(v)\)
For all \(v\): \(\texttt{edgeToParent}(v) = \{ v, \texttt{parent}(v)\} \)
For all \(v \neq M.\texttt{root}\): \(\texttt{edgeToParent}(v) \in M.\texttt{graph.graph.edgeSet}\)
Given a spanning tree \(T\) and edge outcomes \(z\), the path parity chain \(c' : \texttt{VertexChain } M\) is defined recursively by:
The recursion is well-founded since \(\texttt{depth}(\texttt{parent}(v)) {\lt} \texttt{depth}(v)\) for non-root vertices.
An edge chain \(z\) is in the image of \(\delta _0\) if there exists a vertex chain \(c\) such that \(\delta _0(c) = z\):
For any vertex chain \(c\), \(\delta _0(c)\) is in the image of \(\delta _0\).
We have \(c\) itself as a witness: \(\delta _0(c) = \delta _0(c)\).
For any spanning tree \(T\) and edge outcomes \(z\):
Unfolding the definition of \(\texttt{pathParityChain}\), since \(M.\texttt{root} = M.\texttt{root}\), the condition is true and we return \(0\). By simplification, this equals \(0\).
For any spanning tree \(T\), edge outcomes \(z\), and vertex \(v \neq M.\texttt{root}\):
where \(c' = \texttt{pathParityChain}(T, z)\).
We unfold \(\texttt{pathParityChain}\) on the left-hand side. Since \(v \neq M.\texttt{root}\), we have:
Thus:
Using the fact that \(x + x = 0\) in \(\mathbb {Z}_2\), we have \(c'(\texttt{parent}(v)) + c'(\texttt{parent}(v)) = 0\). By ring arithmetic:
For any spanning tree \(T\), edge outcomes \(z\), vertex chain \(c_0\) with \(\delta _0(c_0) = z\), and vertex \(u\):
We proceed by well-founded induction on \(\texttt{depth}(u)\).
Base case: If \(u = M.\texttt{root}\), then by the path parity root lemma, \(\texttt{pathParityChain}(T, z)(u) = 0\). Since \(x + x = 0\) in \(\mathbb {Z}_2\), we have \(c_0(u) + c_0(M.\texttt{root}) = c_0(M.\texttt{root}) + c_0(M.\texttt{root}) = 0\).
Inductive case: Suppose \(u \neq M.\texttt{root}\). Unfolding the definition:
Since \(\texttt{depth}(\texttt{parent}(u)) {\lt} \texttt{depth}(u)\), by the induction hypothesis:
Since \(\delta _0(c_0) = z\), for the edge \(\{ u, \texttt{parent}(u)\} \):
Substituting:
By ring arithmetic and using \(c_0(\texttt{parent}(u)) + c_0(\texttt{parent}(u)) = 0\):
If \(z\) is in the image of \(\delta _0\), then the path parity chain satisfies the byproduct equation \(\delta _0(c') = z\) on ALL edges.
This is the key result: the spanning tree construction recovers a solution to \(\delta _0(c') = z\). The flux constraint (\(z \in \text{im}(\delta _0)\)) is essential—it ensures \(z\) sums to \(0\) on every cycle.
Since \(z\) is in the image of \(\delta _0\), there exists \(c_0\) with \(\delta _0(c_0) = z\).
We show \(\delta _0(c') = z\) by proving equality at every edge. Let \(e = \{ v, w\} \) be an arbitrary edge. We need to show \(c'(v) + c'(w) = z(\{ v, w\} )\).
From \(\delta _0(c_0) = z\):
By Lemma 2596:
Thus:
The key insight is that the constant \(c_0(M.\texttt{root})\) cancels because \(2x = 0\) in \(\mathbb {Z}_2\).
If \(c'\) and \(c''\) both satisfy \(\delta _0(c) = z\), then their difference is in the kernel of \(\delta _0\):
Let \(e = \{ v, w\} \) be an arbitrary edge. We compute:
For connected graphs, any two solutions \(c'\) and \(c''\) of \(\delta _0(c) = z\) differ by a constant: either they are equal, or they differ by \(\mathbf{1}_V\) (the all-ones chain).
By Theorem 2598, the difference \(\lambda v.\, c'(v) + c''(v)\) is in the kernel of \(\delta _0\). For connected graphs, \(\ker (\delta _0) = \{ 0, \mathbf{1}_V\} \), so either \(c' + c'' = 0\) or \(c' + c'' = \mathbf{1}_V\).
If \(c'\) and \(c''\) both satisfy the byproduct equation with \(z\), then either \(c'' = c'\) or \(c'' = c' + \mathbf{1}_V\).
By Theorem 2599, either \(c' + c'' = 0\) or \(c' + c'' = \mathbf{1}_V\).
Case 1: \(c' + c'' = 0\). For each vertex \(v\), we have \(c'(v) + c''(v) = 0\). Using \(x + x = 0\) in \(\mathbb {Z}_2\):
So \(c'' = c'\).
Case 2: \(c' + c'' = \mathbf{1}_V\). For each vertex \(v\), we have \(c'(v) + c''(v) = 1\). By similar arithmetic:
So \(c'' = c' + \mathbf{1}_V\).
A vertex \(v\) is reachable with depth \(d\) from the root in measurement configuration \(M\) if there exists a walk \(p\) in \(M.\texttt{graph.graph}\) from \(M.\texttt{root}\) to \(v\) with \(\texttt{length}(p) \leq d\).
For a connected graph in measurement configuration \(M\), every vertex \(v\) is reachable from \(M.\texttt{root}\).
This follows directly from the connectivity of the graph: \(M.\texttt{graph.connected.preconnected}\) ensures that any two vertices are connected.
For any connected finite graph in measurement configuration \(M\), a spanning tree exists.
We construct the spanning tree using graph distance from the root as the depth function.
For each non-root vertex \(v\), we need to find a neighbor \(w\) with \(\texttt{dist}(M.\texttt{root}, w) {\lt} \texttt{dist}(M.\texttt{root}, v)\). Such a neighbor exists on any shortest path from the root to \(v\).
Let \(v \neq M.\texttt{root}\). By connectivity, \(v\) is reachable from the root. Since \(v \neq M.\texttt{root}\), the distance \(\texttt{dist}(M.\texttt{root}, v) {\gt} 0\).
Let \(p\) be a shortest path from \(M.\texttt{root}\) to \(v\). Since the path has positive length, we can decompose \(p.\texttt{reverse}\) (a path from \(v\) to \(M.\texttt{root}\)) to obtain a vertex \(u\) adjacent to \(v\) with \(\texttt{dist}(M.\texttt{root}, u) {\lt} \texttt{dist}(M.\texttt{root}, v)\).
We then define:
\(\texttt{parent}(v) = u\) for non-root \(v\), and \(\texttt{parent}(M.\texttt{root}) = M.\texttt{root}\)
\(\texttt{depth}(v) = \texttt{dist}(M.\texttt{root}, v)\)
\(\texttt{edgeToParent}(v) = \{ v, \texttt{parent}(v)\} \)
The required properties follow:
\(\texttt{depth}(M.\texttt{root}) = \texttt{dist}(M.\texttt{root}, M.\texttt{root}) = 0\)
Non-root vertices have positive depth since they are distinct from the root
Parent has smaller depth by construction
Edges to parent are graph edges by the adjacency property
Given a measurement configuration \(M\) and edge outcomes \(z\) satisfying the flux constraint (\(z \in \text{im}(\delta _0)\)), there exists a vertex chain \(c'\) such that:
\(c'(M.\texttt{root}) = 0\)
\(\delta _0(c') = z\) (on ALL edges)
\(c'\) is unique up to adding \(\mathbf{1}_V\): for any \(c''\) satisfying \(\delta _0(c'') = z\), either \(c'' = c'\) or \(c'' = c' + \mathbf{1}_V\)
By Theorem 2603, there exists a spanning tree \(T\) for \(M\).
Let \(c' = \texttt{pathParityChain}(T, z)\).
For any list \(\texttt{path}\) of type \(\alpha \):
We proceed by induction on the list.
Base case: For the empty list, \(\texttt{List.foldl}(\ldots , 0, []) = 0\) by definition.
Inductive case: For \(\texttt{cons}(h, \texttt{tl})\), we unfold the definition:
Since \(0 + 0 = 0\), this equals \(\texttt{List.foldl}(\ldots , 0, \texttt{tl})\), which equals \(0\) by the induction hypothesis.
For any spanning tree \(T\) and any vertex \(v\):
We proceed by strong induction on \(\texttt{depth}(v)\).
Base case: If \(v = M.\texttt{root}\), then by Lemma 2594, \(\texttt{pathParityChain}(T, \lambda \_ .\, 0)(v) = 0\).
Inductive case: Suppose \(v \neq M.\texttt{root}\). Unfolding the definition:
Since \(\texttt{depth}(\texttt{parent}(v)) {\lt} \texttt{depth}(v)\), by the induction hypothesis:
Thus \(\texttt{pathParityChain}(T, \lambda \_ .\, 0)(v) = 0 + 0 = 0\).
1.22 Cycle Rank Formula
This section establishes the cycle rank formula for graphs. For a connected graph \(G = (V, E)\), the cycle rank (also called the cyclomatic number or first Betti number) is:
This fundamental quantity equals:
The dimension of \(\ker (\partial _1)\) (the space of 1-cycles)
The number of edges not in any spanning tree
The minimum number of edges that must be removed to make \(G\) acyclic
1.22.1 Cycle Rank Definition
The cycle rank (cyclomatic number, first Betti number) of a graph with \(|E|\) edges, \(|V|\) vertices, and \(c\) connected components is defined as:
For a connected graph (where \(c = 1\)), this equals the dimension of the cycle space \(\ker (\partial _1)\).
For a connected graph, the cycle rank is:
This is the specialization of the general cycle rank formula to the case \(c = 1\).
1.22.2 Basic Properties
For a connected graph with \(|E|\) edges and \(|V|\) vertices:
By unfolding the definitions of cycleRankConnected and cycleRank, and simplifying the cast of the natural number \(1\), the result follows immediately from the definition.
Cycle rank is additive over disjoint unions of graphs. If a graph has two subgraphs with parameters \((e_1, v_1, c_1)\) and \((e_2, v_2, c_2)\) respectively, then:
Unfolding the definition of cycle rank, we have:
The result follows by ring arithmetic.
For any \(e, v \in \mathbb {N}\):
By unfolding the definitions of cycleRankConnected and cycleRank, and simplifying the cast of \(1\), we obtain the formula directly.
1.22.3 Trees Have Zero Cycle Rank
A tree has \(|E| = |V| - 1\) edges, so its cycle rank is \(0\). Specifically, for \(|V| \geq 1\):
This formalizes property (ii): the number of edges not in a spanning tree is zero for a tree.
Unfolding the definitions of cycleRankConnected and cycleRank, we compute:
The result follows by integer arithmetic (omega).
Adding one edge to a graph increases the cycle rank by \(1\):
Unfolding the definitions and using the casts of natural numbers to integers:
The result follows by ring arithmetic.
Removing one edge from a graph (with \(|E| \geq 1\)) decreases the cycle rank by \(1\):
Unfolding the definitions, the result follows by integer arithmetic (omega).
1.22.4 Non-negativity for Connected Graphs
For a connected graph satisfying \(|E| + 1 \geq |V|\) (which holds since a spanning tree exists), the cycle rank is non-negative:
Unfolding the definitions, we need to show \(0 \leq |E| - |V| + 1\). Given the hypothesis \(|E| + 1 \geq |V|\), this follows by integer arithmetic (omega).
For a connected graph satisfying \(|E| + 1 \geq |V|\):
This follows directly from the hypothesis by integer arithmetic (omega).
1.22.5 Chain Space Dimensions
The dimension of the edge space \(C_1\) equals the number of edges:
The edge space \(C_1\) is defined as \((\mathbb {Z}/2\mathbb {Z})^E\). Using the fact that the finite rank of a product type equals the sum of ranks (each factor having rank \(1\)), and that this sum over a finite set of constants equals the cardinality times the constant, we obtain \(\dim (C_1) = |E| \cdot 1 = |E|\).
The dimension of the vertex space \(C_0\) equals the number of vertices:
The vertex space \(C_0\) is defined as \((\mathbb {Z}/2\mathbb {Z})^V\). By the same reasoning as for \(C_1\), we have \(\dim (C_0) = |V|\).
The dimension of the cycle space \(C_2\) equals the number of cycles:
The cycle space \(C_2\) is defined as \((\mathbb {Z}/2\mathbb {Z})^C\). By the same reasoning, \(\dim (C_2) = |C|\).
1.22.6 Rank-Nullity for Boundary Map
The key connection between the combinatorial cycle rank formula and the algebraic definition \(\dim (\ker (\partial _1))\) comes from the rank-nullity theorem:
This gives \(\dim (\ker (\partial _1)) = |E| - \dim (\mathrm{im}(\partial _1))\).
For a connected graph, \(\dim (\mathrm{im}(\partial _1)) = |V| - 1\) (since \(\mathrm{im}(\partial _1)\) is the space of even-parity \(0\)-chains, which has codimension \(1\)). This yields:
The rank-nullity theorem applied to the boundary map \(\partial _1\) gives:
We apply the rank-nullity theorem for linear maps: \(\dim (\ker (f)) + \dim (\mathrm{im}(f)) = \dim (\text{domain})\). For \(\partial _1 : C_1 \to C_0\), this gives \(\dim (\ker (\partial _1)) + \dim (\mathrm{im}(\partial _1)) = \dim (C_1)\). By Theorem 2617, \(\dim (C_1) = |E|\). Rewriting with commutativity of addition yields the result.
Given the dimension of the image of \(\partial _1\), we can compute the dimension of the kernel:
From the rank-nullity theorem (Theorem 2620):
Rearranging by integer arithmetic (omega) gives \(\dim (\ker (\partial _1)) = |E| - \dim (\mathrm{im}(\partial _1))\).
If \(\dim (\mathrm{im}(\partial _1)) = |V| - 1\) (which holds for connected graphs), \(|V| \geq 1\), and \(|E| + 1 \geq |V|\), then:
The condition \(\dim (\mathrm{im}(\partial _1)) = |V| - 1\) holds for connected graphs because:
The image of \(\partial _1\) consists of \(0\)-chains with even total parity
This is a codimension-\(1\) subspace of \(C_0\) (which has dimension \(|V|\))
For connected graphs, every even-parity \(0\)-chain is achievable
1.22.7 Properties of the Parity Map
The parity map \(\pi : C_0 \to \mathbb {Z}/2\mathbb {Z}\) sums all coefficients of a \(0\)-chain:
A \(0\)-chain is in \(\mathrm{im}(\partial _1)\) if and only if its parity is \(0\).
The boundary of any edge has even parity (exactly \(2\) vertices contribute \(1\) each):
Let \(e\) be an edge with distinct endpoints \(v_1 = (\mathrm{endpoints}(e))_1\) and \(v_2 = (\mathrm{endpoints}(e))_2\) (distinct by the graph configuration). The boundary \(\partial _1(e)\) is \(1\) at \(v_1\) and \(v_2\), and \(0\) elsewhere.
Splitting the sum over vertices:
in \(\mathbb {Z}/2\mathbb {Z}\), since \(1 + 1 = 0\) (verified by computation: decide).
The boundary of any \(1\)-chain has even parity:
By linearity of both the boundary map and the parity map, and using Fubini’s theorem to swap sums:
By Theorem 2624, \(\sum _{v \in V} \partial _1(e)(v) = \pi (\partial _1(e)) = 0\) for each edge \(e\). Thus each term \(\alpha (e) \cdot 0 = 0\), and the entire sum is \(0\).
The image of \(\partial _1\) is contained in the kernel of the parity map:
Let \(x \in \mathrm{im}(\partial _1)\). Then there exists \(\alpha \in C_1\) such that \(x = \partial _1(\alpha )\). By Theorem 2625, \(\pi (x) = \pi (\partial _1(\alpha )) = 0\), so \(x \in \ker (\pi )\).
1.22.8 SimpleGraph Cycle Rank
The cycle rank of a simple graph \(G\) on a finite vertex type \(V\) is:
where \(|E(G)|\) is the cardinality of the edge set.
For a simple graph \(G\):
Unfolding the definition of simpleGraphCycleRank and applying Lemma 2611, the result follows directly.
A tree on a nonempty finite vertex type has exactly \(|V| - 1\) edges (formulated as \(|E| + 1 = |V|\)):
This follows directly from Mathlib’s theorem SimpleGraph.IsTree.card_edgeFinset.
A tree has cycle rank \(0\):
Unfolding the definition of simpleGraphCycleRank, we have \(\beta _1(T) = |E(T)| - |V| + 1\). By Theorem 2629, \(|E(T)| + 1 = |V|\), so \(|E(T)| = |V| - 1\). Substituting:
The result follows by integer arithmetic (omega).
A connected graph has at least \(|V| - 1\) edges:
We consider two cases based on whether the vertex type is nonempty.
Case 1: If \(V\) is nonempty, we use Mathlib’s theorem that for connected graphs, \(|V| \leq |E| + 1\) (specifically, SimpleGraph.Connected.card_vert_le_card_edgeSet_add_one). Converting between Nat.card and Fintype.card, and noting that \(|E(G)|\) equals the cardinality of the edge set, we obtain \(|E(G)| + 1 \geq |V|\).
Case 2: If \(V\) is empty, then \(|V| = 0\), so \(|E(G)| + 1 \geq 0\) holds trivially.
The cycle rank of a connected graph is non-negative:
1.22.9 Edges Outside Spanning Tree
The cycle rank equals the number of edges not in any spanning tree. For a connected graph with spanning tree \(T\):
The number of edges not in a spanning tree equals the cycle rank:
Unfolding the definitions, we compute:
The result follows by integer arithmetic (omega).
1.22.10 Minimum Edge Removal
The cycle rank equals the minimum number of edges to remove to make \(G\) acyclic. Removing one edge from a cycle reduces the cycle rank by \(1\), and when cycle rank reaches \(0\), the graph is a tree (acyclic).
For a connected graph with \(|V| \geq 1\), the cycle rank is zero if and only if the graph is a tree (has exactly \(|V| - 1\) edges):
Unfolding the definitions:
The result follows by integer arithmetic (omega).
Removing \(k\) edges (where \(k \leq |E|\)) reduces the cycle rank by \(k\):
Unfolding the definitions:
The result follows by integer arithmetic (omega).
For a connected graph with \(|E| + 1 \geq |V|\) and \(|V| \geq 1\), the minimum number of edges to remove to achieve cycle rank \(0\) is exactly the cycle rank:
Take \(k = |E| - (|V| - 1)\). We verify both conditions:
Condition 1: \(\beta _1(|E| - k, |V|) = \beta _1(|V| - 1, |V|) = (|V| - 1) - |V| + 1 = 0\).
Condition 2: \(k = |E| - (|V| - 1) = |E| - |V| + 1 = \beta _1(|E|, |V|)\).
Both equalities follow by integer arithmetic (omega).
1.22.11 Helper Lemmas
Cycle rank is preserved under graph isomorphism (graphs with the same edge and vertex counts have the same cycle rank):
Given \(e_1 = e_2\) and \(v_1 = v_2\), we substitute to obtain \(\beta _1(e_1, v_1) = \beta _1(e_2, v_2)\) immediately by rewriting.
Cycle rank with zero vertices equals the edge count plus \(1\):
Unfolding the definitions:
The result follows by simplification.
Cycle rank with zero edges:
Unfolding the definitions:
The result follows by simplification and ring arithmetic.
The single vertex graph (with \(0\) edges) has cycle rank \(0\):
Unfolding the definitions and computing: \(0 - 1 + 1 = 0\). Verified by norm_num.
The single edge graph (\(2\) vertices, \(1\) edge) has cycle rank \(0\):
Unfolding the definitions and computing: \(1 - 2 + 1 = 0\). Verified by norm_num.
A cycle graph with \(n\) vertices has \(n\) edges and cycle rank \(1\):
Unfolding the definitions:
The result follows by simplification.
Adding an edge between existing vertices increases cycle rank by \(1\):
Unfolding the definitions and using the casts of natural numbers:
The result follows by ring arithmetic.
Adding a new vertex with one edge keeps the cycle rank the same:
Unfolding the definitions:
The result follows by ring arithmetic.
1.23 Tanner Graph
The Tanner graph of a stabilizer code is a bipartite graph \(T = (Q \cup C, E_T)\) where:
\(Q\) = set of qubit nodes (one per physical qubit)
\(C\) = set of check nodes (one per stabilizer generator)
\(E_T\) = edges connecting qubit \(q\) to check \(c\) if and only if \(c\) acts non-trivially on \(q\)
For CSS codes, the Tanner graph can be split into X-type and Z-type subgraphs:
\(T_X\): connects qubits to X-type checks
\(T_Z\): connects qubits to Z-type checks
A code is LDPC if and only if its Tanner graph has bounded degree (both qubit and check degrees bounded by constants).
1.23.1 Tanner Node Type
A node in a Tanner graph is either a qubit node or a check node. We use a sum type to represent the bipartite structure:
A predicate that returns true if and only if the node is a qubit node:
A predicate that returns true if and only if the node is a check node:
Returns the qubit index if this is a qubit node, otherwise returns none:
Returns the check index if this is a check node, otherwise returns none:
For any qubit index \(q\) and check index \(c\), we have \(\text{qubit}(q) \neq \text{check}(c)\).
Assume for contradiction that \(\text{qubit}(q) = \text{check}(c)\). By case analysis on this equality, the two constructors are distinct, leading to a contradiction.
For any check index \(c\) and qubit index \(q\), we have \(\text{check}(c) \neq \text{qubit}(q)\).
Assume for contradiction that \(\text{check}(c) = \text{qubit}(q)\). By case analysis on this equality, the two constructors are distinct, leading to a contradiction.
1.23.2 Tanner Graph for Stabilizer Codes
The Tanner graph of a stabilizer code is a bipartite graph \(T = (Q \cup C, E_T)\) where:
\(Q\) = qubit nodes (one per physical qubit)
\(C\) = check nodes (one per stabilizer generator)
Edge \((q, c)\) exists if and only if check \(c\) acts non-trivially on qubit \(q\)
Formally, a Tanner graph consists of:
The underlying stabilizer code \(C\)
A simple graph on qubit and check nodes
Decidable adjacency
The bipartite property: edges only connect qubits to checks
Adjacency matches check support: qubit \(q\) is adjacent to check \(c\) if and only if \(c\) acts on \(q\)
The number of qubit nodes in a Tanner graph \(T\) is \(n\), where \(n\) is the number of physical qubits in the underlying code.
The number of check nodes in a Tanner graph \(T\) is \(n - k\), where \(n\) is the number of physical qubits and \(k\) is the dimension of the code.
The total number of nodes in a Tanner graph \(T\) is the sum of qubit nodes and check nodes:
The degree of a qubit node \(q\) in the Tanner graph is the number of checks that act non-trivially on qubit \(q\). This equals the number of check nodes adjacent to \(q\) in the graph.
The degree of a check node \(c\) in the Tanner graph is the weight of the check, i.e., the number of qubits on which check \(c\) acts non-trivially.
An alternative definition of qubit degree using a filter:
An alternative definition of check degree:
For a Tanner graph \(T\) and check \(c\), the check degree filter equals the check weight:
By unfolding the definitions of checkDegreeFilter and StabilizerCheck.weight, we see that both count the cardinality of the same set. By extensionality on the filter condition, using simplification of membership in filter, universe, and union, the two sets are equal, hence their cardinalities are equal.
1.23.3 Construct Tanner Graph from Stabilizer Code
The adjacency relation for the Tanner graph of a stabilizer code is defined by:
The Tanner adjacency relation is symmetric.
Let \(v\) and \(w\) be nodes such that \(\text{tannerAdjacency}(v, w)\) holds. By unfolding the definition of tannerAdjacency at both the hypothesis and goal, we perform case analysis on both \(v\) and \(w\). In each case, simplification with the hypothesis shows that \(\text{tannerAdjacency}(w, v)\) holds, since the definition is symmetric between qubit-check and check-qubit cases, and the other cases are vacuously true.
The Tanner adjacency relation is irreflexive (no self-loops).
Let \(v\) be any node. By unfolding the definition of tannerAdjacency and performing case analysis on \(v\), we see that \(\text{tannerAdjacency}(v, v)\) reduces to False in all cases (both qubit-qubit and check-check adjacencies are defined to be False).
Given a stabilizer code, construct its Tanner graph by:
Setting the code field to the given code
Constructing the simple graph using tannerAdjacency as the adjacency relation
Using the symmetry and irreflexivity theorems to satisfy the simple graph requirements
Using decidability of membership to provide decidable adjacency
Proving the bipartite property by case analysis on nodes
Proving adjacency matches support membership by simplification
1.23.4 CSS Tanner Graph
The X-type Tanner graph for a CSS code connects qubits to X-type checks only. It consists of:
The underlying CSS code
A simple graph on qubit and X-check nodes
Adjacency matches X-check support: qubit \(q\) is adjacent to X-check \(c\) if and only if \(q \in \text{rowSupport}(H_X, c)\)
The Z-type Tanner graph for a CSS code connects qubits to Z-type checks only. It consists of:
The underlying CSS code
A simple graph on qubit and Z-check nodes
Adjacency matches Z-check support: qubit \(q\) is adjacent to Z-check \(c\) if and only if \(q \in \text{rowSupport}(H_Z, c)\)
The combined CSS Tanner graph with both X and Z subgraphs consists of:
The underlying CSS code
The X-type subgraph \(T_X\)
The Z-type subgraph \(T_Z\)
Consistency conditions ensuring both subgraphs use the same code
1.23.5 LDPC Condition via Tanner Graph
A code is LDPC if its Tanner graph has bounded degree. Specifically, for parameters \(w\) and \(\Delta \):
Each check has degree (weight) at most \(w\): \(\forall c, \text{checkDegreeFilter}(T, c) \leq w\)
Each qubit has degree at most \(\Delta \): \(\forall q, \text{qubitDegreeFilter}(T, q) \leq \Delta \)
The LDPC condition on the Tanner graph is equivalent to the code’s IsLDPC property:
We prove both directions:
\((\Rightarrow )\) Assume TannerLDPC with bounds \(\langle h_{\text{check}}, h_{\text{qubit}} \rangle \). We construct IsLDPC as follows. For the weight bound, given index \(i\), we have \(h := h_{\text{check}}(i)\) and rewriting with the theorem that checkDegreeFilter equals weight, we get the required bound. For the degree bound, given vertex \(v\), we directly use \(h_{\text{qubit}}(v)\).
\((\Leftarrow )\) Assume IsLDPC with bounds \(\langle h_{\text{weight}}, h_{\text{degree}} \rangle \). We construct TannerLDPC as follows. For the check degree bound, given \(c\), we rewrite with checkDegreeFilter equals weight and use \(h_{\text{weight}}(c)\). For the qubit degree bound, given \(q\), we directly use \(h_{\text{degree}}(q)\).
1.23.6 Deformed Code Tanner Graph
A node type for the deformed code Tanner graph. After gauging, we have:
Original qubit nodes \(Q\)
Edge qubit nodes \(E\) (auxiliary qubits from gauging)
Gauss’s law check nodes \(A\)
Flux check nodes \(B\)
Original check nodes \(C\)
Formally:
The deformed code Tanner graph structure represents the Tanner graph after gauging, with:
Qubit nodes \(Q\) (original) and \(E\) (edge qubits from gauging)
Check nodes \(A\) (Gauss), \(B\) (flux), and \(C'\) (deformed original checks)
The structure contains:
Number of edge qubits
Number of Gauss’s law checks (= number of vertices in \(G\))
Number of flux checks (= cycle rank of \(G\))
Number of original deformed checks
Proof that edge qubits correspond to edges of \(G\)
Proof that Gauss checks correspond to vertices of \(G\)
1.23.7 Bipartite Property of Tanner Graph
The set of qubit nodes in the Tanner graph:
The set of check nodes in the Tanner graph:
The qubit and check sets of a Tanner graph are disjoint:
We rewrite disjointness in terms of set intersection. Let \(v\) be in both sets, so \(h_q : v.\text{isQubit} = \text{true}\) and \(h_c : v.\text{isCheck} = \text{true}\). Simplifying the definitions of qubitSet and checkSet, we perform case analysis on \(v\). In each case, by the definitions of isQubit and isCheck, we cannot have both predicates true simultaneously, yielding a contradiction.
Every node in the Tanner graph is either a qubit or a check:
By extensionality, we show that for any \(v\), \(v \in \text{qubitSet}(T) \cup \text{checkSet}(T)\) if and only if \(v \in \text{univ}\). Simplifying membership in union, qubitSet, checkSet, and univ, and performing case analysis on \(v\), each case reduces to a disjunction where one side is trivially true by the definitions of isQubit and isCheck.
1.23.8 Helper Lemmas
The Tanner graph has no edges between qubits: for any qubits \(q_1, q_2\),
Assume for contradiction that there is an edge \(h\) between \(\text{qubit}(q_1)\) and \(\text{qubit}(q_2)\). By the bipartite property, either \((\text{qubit}(q_1).\text{isQubit} \land \text{qubit}(q_2).\text{isCheck})\) or \((\text{qubit}(q_1).\text{isCheck} \land \text{qubit}(q_2).\text{isQubit})\). Simplifying with the facts that isQubit is true and isCheck is false for qubit nodes, both disjuncts are false, yielding a contradiction.
The Tanner graph has no edges between checks: for any checks \(c_1, c_2\),
Assume for contradiction that there is an edge \(h\) between \(\text{check}(c_1)\) and \(\text{check}(c_2)\). By the bipartite property, either \((\text{check}(c_1).\text{isQubit} \land \text{check}(c_2).\text{isCheck})\) or \((\text{check}(c_1).\text{isCheck} \land \text{check}(c_2).\text{isQubit})\). Simplifying with the facts that isQubit is false and isCheck is true for check nodes, both disjuncts are false, yielding a contradiction.
A qubit is adjacent to a check if and only if the check acts non-trivially on that qubit:
This follows directly from the adjacency_support field of the Tanner graph structure.
Adjacency is symmetric: check-qubit if and only if qubit-check:
By the commutativity of adjacency in simple graphs, we have \(T.\text{graph}.\text{Adj}(\text{check}(c), \text{qubit}(q)) \Leftrightarrow T.\text{graph}.\text{Adj}(\text{qubit}(q), \text{check}(c))\). The result then follows from the adjacency_support property.
For CSS codes, X and Z Tanner graphs partition the edges. For any qubit \(q\):
We consider cases. First, we check if there exists an X-check \(c\) such that \(q \in \text{rowSupport}(H_X, c)\). If so, the first disjunct holds. Otherwise, we check if there exists a Z-check \(c\) such that \(q \in \text{rowSupport}(H_Z, c)\). If so, the second disjunct holds. If neither, by pushing negations through the existential quantifiers, we obtain the third disjunct showing \(q\) is not in the support of any check.
The number of qubit nodes equals \(n\):
This holds by reflexivity, as numQubitNodes is defined to be \(n\).
The number of check nodes equals \(n - k\):
This holds by reflexivity, as numCheckNodes is defined to be \(n - k\).
The Tanner graph of a code with identity checks (empty support) has no edges from that check. If \((\text{code.checks}(c)).\text{supportX} = \emptyset \) and \((\text{code.checks}(c)).\text{supportZ} = \emptyset \), then for all qubits \(q\):
Let \(q\) be any qubit and assume for contradiction that there is an adjacency. By the adjacency_support property of mkTannerGraph, we have \(q \in \text{supportX} \cup \text{supportZ}\). Since mkTannerGraph.code = code by definition, and by hypothesis both supports are empty, the union is empty. Thus \(q \in \emptyset \), which by the fact that nothing is in the empty set yields a contradiction.
The check weight equals the number of adjacent qubits:
By unfolding the definition of StabilizerCheck.weight, it suffices to show that the filtered sets have equal cardinality. By extensionality on the filter condition, using simplification of membership in filter, universe, and union, then rewriting with the adjacency_support property and simplifying membership in union, the two filter conditions are equivalent.
For mkTannerGraph, adjacency is exactly support membership:
This follows directly from the adjacency_support field of the mkTannerGraph construction.
The qubit degree filter counts the checks that act on a qubit:
This holds by reflexivity, as both definitions compute the same quantity.
[Matching Matrix \(M\)]
The matching matrix \(M\) in the deformed code Tanner graph encodes how original checks are deformed by paths in the gauging graph \(G\).
Structure: \(M\) is a binary matrix with:
Rows indexed by checks in \(S\) (checks with \(Z\)-support on \(L\))
Columns indexed by edges in \(G\)
\(M_{j,e} = 1\) if and only if edge \(e\) is in the deforming path \(\gamma _j\) for check \(s_j\)
Optimization goal: Choose paths \(\{ \gamma _j\} \) to minimize:
Row weight of \(M\) (path lengths)
Column weight of \(M\) (edge participation in multiple paths)
Perfect matching approach: When \(|S_{Z,j} \cap V| = 2\) for all checks \(s_j \in S\), a \(\mathbb {Z}_2\)-perfect-matching ensures each row of \(M\) has weight \(1\).
No proof needed for remarks.
The set of Type \(S\) check indices for a logical operator \(L\) is defined as
These are the checks with \(Z\)-support on \(L\), which are exactly the rows of the matching matrix \(M\).
The number of Type \(S\) checks for a logical operator \(L\) is the cardinality of the set of Type \(S\) check indices:
A matching matrix configuration for a stabilizer code \(C\), logical operator \(L\), and gauging graph \(G\) consists of:
A set of Type \(S\) check indices \(\mathrm{typeSChecks} \subseteq \mathrm{Fin}(n-k)\)
A function \(\mathrm{checkPathSet} : \mathrm{Fin}(n-k) \to \mathcal{P}(\mathrm{Sym}_2(V))\) mapping each check to its set of path edges
A proof that non-Type \(S\) checks have empty path sets
A proof that all edges in paths are valid graph edges
This encodes the paths \(\gamma _j\) chosen for each Type \(S\) check \(s_j\).
The entry \(M_{j,e}\) of the matching matrix is defined as:
where all arithmetic is in \(\mathbb {Z}_2\).
For a matching matrix configuration \(M\), check \(j\), and edge \(e\):
We unfold the definition of entry. For the forward direction, assume \(M_{j,e} = 1\). We consider two cases: if \(e \in \mathrm{checkPathSet}(j)\), we are done. If \(e \notin \mathrm{checkPathSet}(j)\), then by definition \(M_{j,e} = 0\), which contradicts our assumption (verified by computation). For the reverse direction, if \(e \in \mathrm{checkPathSet}(j)\), then by definition \(M_{j,e} = 1\).
For a matching matrix configuration \(M\), check \(j\), and edge \(e\):
We unfold the definition of entry. For the forward direction, assume \(M_{j,e} = 0\). We consider two cases: if \(e \in \mathrm{checkPathSet}(j)\), then by definition \(M_{j,e} = 1\), which contradicts our assumption (verified by computation). Thus \(e \notin \mathrm{checkPathSet}(j)\). For the reverse direction, if \(e \notin \mathrm{checkPathSet}(j)\), then by definition \(M_{j,e} = 0\).
The row weight of the matching matrix at row \(j\) is the number of edges in the path for check \(j\):
This equals the length of the deforming path \(\gamma _j\).
For a matching matrix configuration \(M\) and check \(j\):
This holds by reflexivity (definitional equality).
If \(j \notin \mathrm{typeSChecks}\), then \(\mathrm{rowWeight}(j) = 0\).
We unfold the definition of row weight. Since \(j \notin \mathrm{typeSChecks}\), by the constraint that non-Type \(S\) checks have empty paths, we have \(\mathrm{checkPathSet}(j) = \emptyset \). Thus the cardinality is \(0\).
The column weight of the matching matrix at column \(e\) is the number of checks whose path contains edge \(e\):
This measures how many deforming paths pass through edge \(e\).
For a matching matrix configuration \(M\) and edge \(e\):
This holds by reflexivity (definitional equality).
The column weight can be computed by only considering Type \(S\) checks:
We unfold the definition of column weight. It suffices to show the two filtered sets have the same elements. By extensionality, for any \(j\): if \(e \in \mathrm{checkPathSet}(j)\), then \(j\) must be in \(\mathrm{typeSChecks}\) (otherwise the path set would be empty by the non-Type \(S\) constraint, contradicting membership). Conversely, if \(j \in \mathrm{typeSChecks}\) and \(e \in \mathrm{checkPathSet}(j)\), then clearly \(e \in \mathrm{checkPathSet}(j)\).
The total row weight of a matching matrix configuration is the sum of all path lengths:
The maximum column weight of a matching matrix configuration is:
where \(E(G)\) is the edge set of the gauging graph.
An optimization goal consists of:
\(\mathrm{maxRowWeight}\): target maximum row weight (path length bound)
\(\mathrm{maxColWeight}\): target maximum column weight (edge participation bound)
A matching matrix configuration satisfies an optimization goal if:
For all \(j \in \mathrm{typeSChecks}\): \(\mathrm{rowWeight}(j) \leq \mathrm{maxRowWeight}\)
For all edges \(e\): \(\mathrm{colWeight}(e) \leq \mathrm{maxColWeight}\)
The \(Z\)-support size on vertices for check \(j\) is:
This counts qubits in the \(Z\)-support that are also in the support of \(L\).
The condition all Type \(S\) have two vertices holds if:
A matching matrix configuration is a perfect matching if each Type \(S\) row has weight exactly \(1\):
If \(M\) is a perfect matching and \(j \in \mathrm{typeSChecks}\), then \(|\mathrm{checkPathSet}(j)| = 1\).
We unfold the definitions of perfect matching and row weight. Since \(M\) is a perfect matching, we have \(\mathrm{rowWeight}(j) = 1\) for all \(j \in \mathrm{typeSChecks}\). This directly gives \(|\mathrm{checkPathSet}(j)| = 1\).
For a perfect matching \(M\):
We unfold the definition of total row weight. Since \(M\) is a perfect matching, for all \(j \in \mathrm{typeSChecks}\) we have \(\mathrm{rowWeight}(j) = 1\). Thus:
The last equality follows by simplifying the constant sum.
The matching matrix \(M\) as a Mathlib matrix over \(\mathbb {Z}_2\) is defined by:
Rows are indexed by all checks, columns by the given edge set.
For the matching matrix derived from configuration \(M\):
This holds by reflexivity (definitional equality).
For any matching matrix configuration \(M\) and check \(j\):
This holds by reflexivity (definitional equality).
For any matching matrix configuration \(M\) and edge \(e\):
This holds by reflexivity (definitional equality).
The empty matching configuration for gauging graph \(G\) is defined by:
\(\mathrm{typeSChecks} = \emptyset \)
\(\mathrm{checkPathSet}(j) = \emptyset \) for all \(j\)
The non-Type \(S\) constraint holds vacuously, and path edge validity holds because the empty set has no elements.
The empty matching configuration has \(\mathrm{typeSChecks} = \emptyset \).
This holds by reflexivity (definitional equality).
The empty matching configuration has \(\mathrm{totalRowWeight} = 0\).
We unfold the definitions of total row weight and empty matching configuration. Since \(\mathrm{typeSChecks} = \emptyset \), the sum over the empty set is \(0\).
For the empty matching configuration and any check \(j\): \(\mathrm{rowWeight}(j) = 0\).
We unfold the definitions. Since \(\mathrm{checkPathSet}(j) = \emptyset \) for all \(j\), the cardinality is \(0\).
For the empty matching configuration and any edge \(e\): \(\mathrm{colWeight}(e) = 0\).
We unfold the definitions of column weight and empty matching configuration. Since all path sets are empty, no check \(j\) satisfies \(e \in \mathrm{checkPathSet}(j)\). Thus the filter produces the empty set, which has cardinality \(0\).
If all rows have weight at most \(\kappa \), then:
We unfold the definition of total row weight. We have:
The first inequality holds by applying the bound on each term, and the second equality follows from summing a constant.
For a perfect matching \(M\):
We apply the total row weight bound theorem with \(\kappa = 1\). For any \(j \in \mathrm{typeSChecks}\), since \(M\) is a perfect matching, \(\mathrm{rowWeight}(j) = 1 \leq 1\).
For any check index \(j\):
We unfold the definition of type \(S\) check indices. By simplification using membership in filtered sets and the universal finset, the equivalence holds directly.
The number of Type \(S\) checks is at most the total number of checks:
We unfold the definitions. We have:
The first inequality holds because filtering can only reduce cardinality, the first equality is the cardinality of the universal finset, and the second equality is the cardinality of \(\mathrm{Fin}(n-k)\).
For any matching matrix configuration \(M\) and check \(j\): \(\mathrm{rowWeight}(j) \geq 0\).
This follows trivially since row weight is a natural number.
For any matching matrix configuration \(M\) and edge \(e\): \(\mathrm{colWeight}(e) \geq 0\).
This follows trivially since column weight is a natural number.
If \(M\) is a perfect matching and \(j \in \mathrm{typeSChecks}\), then \(\mathrm{rowWeight}(j) = 1\).
This follows directly from the definition of perfect matching applied to \(j\).
If \(j \notin \mathrm{typeSChecks}\), then for any edge \(e\): \(M_{j,e} = 0\).
We rewrite using the characterization that \(M_{j,e} = 0\) iff \(e \notin \mathrm{checkPathSet}(j)\). Since \(j \notin \mathrm{typeSChecks}\), by the non-Type \(S\) constraint we have \(\mathrm{checkPathSet}(j) = \emptyset \). Thus \(e \notin \emptyset \) holds trivially.
For a perfect matching \(M\):
This follows directly from the perfect matching total weight theorem.
A left logical support for a bivariate bicycle code with parameters \(\ell , m\) is a structure representing a logical operator supported on left qubits. It consists of a support set \(S \subseteq \mathrm{Fin}(\ell ) \times \mathrm{Fin}(m)\) of monomial indices where the logical \(X\) operator acts on left qubits. This represents \(\bar{X}_\alpha = \prod _{\beta \in S} X_{(\beta , L)}\).
The weight of a left logical support \(L\) is the cardinality of its support set:
For a left logical support \(L\) and an index \(\mathrm{idx} \in \mathrm{Fin}(\ell ) \times \mathrm{Fin}(m)\), we define \(\mathrm{containsQubit}(L, \mathrm{idx})\) to be true if and only if \(\mathrm{idx} \in L.\mathrm{support}\).
For a bivariate bicycle code \(C\) and a left logical support \(L\), a Z-check indexed by \(\beta \in \mathrm{Fin}(\ell ) \times \mathrm{Fin}(m)\) overlaps with the logical operator if the Z-check acts on any left qubit in \(L\)’s support. Specifically, the Z-check \((\beta , Z)\) acts on left qubits at positions determined by \(\beta \cdot B^T\), and it overlaps with \(L\) if any of these positions intersect \(L.\mathrm{support}\).
The set of overlapping checks for a bivariate bicycle code \(C\) and left logical support \(L\) is:
The set of non-overlapping checks for a bivariate bicycle code \(C\) and left logical support \(L\) is:
For any bivariate bicycle code \(C\) and left logical support \(L\):
By extensionality, it suffices to show that for any \(\beta \), \(\beta \) is in the union if and only if \(\beta \) is in the universal set. By simplification using the definitions of overlapping and non-overlapping checks, this reduces to showing that for any \(\beta \), either \(\mathrm{zCheckOverlapsLogical}(C, L, \beta )\) holds or its negation holds. This follows by tautology.
For any bivariate bicycle code \(C\) and left logical support \(L\), the sets \(\mathrm{overlappingChecks}(C, L)\) and \(\mathrm{nonOverlappingChecks}(C, L)\) are disjoint.
We prove disjointness by showing that no element belongs to both sets. Let \(x \in \mathrm{overlappingChecks}(C, L)\) and \(y \in \mathrm{nonOverlappingChecks}(C, L)\). Suppose for contradiction that \(x = y\). Then by the definitions, \(\mathrm{zCheckOverlapsLogical}(C, L, x)\) holds (from membership in overlapping checks) and \(\neg \mathrm{zCheckOverlapsLogical}(C, L, x)\) holds (from membership in non-overlapping checks after rewriting with \(x = y\)). This is a contradiction.
The check row space is the vector space of row vectors over \(\mathbb {Z}_2\) indexed by check indices:
The qubit column space is the vector space of column vectors over \(\mathbb {Z}_2\) indexed by qubit indices (with \(2 \cdot \ell \cdot m\) qubits total, distinguished by a Boolean for left/right):
The \(H_Z\) parity check matrix is defined as a linear map from qubits to syndromes. For a bivariate bicycle code \(C\), we have \(H_Z = [B^T \mid A^T]\) where \(B^T\) acts on left qubits and \(A^T\) acts on right qubits. Explicitly, for a qubit vector \(q\) and check index \(\beta \):
The overlapping row subspace for code \(C\) and logical support \(L\) is the submodule of check row vectors that are zero outside the overlapping checks:
This represents the row space of the submatrix \(S\) of \(H_Z\) restricted to checks overlapping with \(\bar{X}_\alpha \).
The non-overlapping row subspace for code \(C\) and logical support \(L\) is the submodule of check row vectors that are zero outside the non-overlapping checks:
This represents the row space of the submatrix \(C\) of \(H_Z\) restricted to checks not overlapping with \(\bar{X}_\alpha \).
The left kernel of \(H_Z\) is the submodule of check row vectors \(u\) such that \(u^T \cdot H_Z = 0\):
The full row nullity of \(H_Z\) for code \(C\) is the dimension of its left kernel:
The redundant cycle space for code \(C\) and logical support \(L\) is the submodule:
This captures vectors \(u\) in the overlapping check subspace such that there exists \(v\) in the non-overlapping check subspace with \(uS + vC = 0\).
The redundant cycle dimension is:
The projection to overlapping check coordinates is the linear map:
The projection to non-overlapping check coordinates is the linear map:
The left kernel restricted to non-overlapping checks is the intersection:
This represents the row nullity of the submatrix \(C\).
The row nullity of submatrix \(C\) (non-overlapping checks) is:
The kernel projection is a linear map from the left kernel of \(H_Z\) to the check row space, defined by projecting to the overlapping check coordinates:
for \(w \in \mathrm{leftKernel}(C)\).
For any \(w \in \mathrm{leftKernel}(C)\):
Let \(w \in \mathrm{leftKernel}(C)\). We prove both directions.
\((\Rightarrow )\): Assume \(\mathrm{kernelProjection}(C, L)(w) = 0\). We need to show \(w \in \mathrm{leftKernelNonOverlapping}(C, L)\), which means \(w \in \mathrm{NonOverlappingRowSubspace}(C, L) \cap \mathrm{leftKernel}(C)\).
For the non-overlapping row subspace membership, let \(\beta \notin \mathrm{nonOverlappingChecks}(C, L)\). By the check partition theorem, \(\beta \in \mathrm{overlappingChecks}(C, L) \cup \mathrm{nonOverlappingChecks}(C, L)\). Since \(\beta \notin \mathrm{nonOverlappingChecks}(C, L)\), we must have \(\beta \in \mathrm{overlappingChecks}(C, L)\). By the assumption that the kernel projection is zero, evaluating at \(\beta \) gives \(w_\beta = 0\).
The membership in \(\mathrm{leftKernel}(C)\) follows directly from the hypothesis that \(w \in \mathrm{leftKernel}(C)\).
\((\Leftarrow )\): Assume \(w \in \mathrm{leftKernelNonOverlapping}(C, L)\). By extensionality, we show \((\mathrm{kernelProjection}(C, L)(w))_\beta = 0\) for all \(\beta \).
If \(\beta \in \mathrm{overlappingChecks}(C, L)\), then by the disjointness of checks (Theorem 2733), \(\beta \notin \mathrm{nonOverlappingChecks}(C, L)\). Since \(w \in \mathrm{NonOverlappingRowSubspace}(C, L)\), we have \(w_\beta = 0\), so the projection equals \(0\).
If \(\beta \notin \mathrm{overlappingChecks}(C, L)\), then by definition of the kernel projection, \((\mathrm{kernelProjection}(C, L)(w))_\beta = 0\).
The redundant cycle space equals the image of the kernel projection as sets:
We prove set equality by showing both inclusions.
\((\subseteq )\): Let \(u \in \mathrm{RedundantCycleSpace}(C, L)\). By definition, \(u \in \mathrm{OverlappingRowSubspace}(C, L)\) and there exists \(v \in \mathrm{NonOverlappingRowSubspace}(C, L)\) with \((u + v) \in \mathrm{leftKernel}(C)\).
Consider \(w = u + v \in \mathrm{leftKernel}(C)\). We claim \(\mathrm{kernelProjection}(C, L)(w) = u\).
By extensionality, for any \(\beta \): If \(\beta \in \mathrm{overlappingChecks}(C, L)\), then by disjointness, \(\beta \notin \mathrm{nonOverlappingChecks}(C, L)\), so \(v_\beta = 0\) (since \(v \in \mathrm{NonOverlappingRowSubspace}\)). Thus \((\mathrm{kernelProjection}(C, L)(w))_\beta = w_\beta = u_\beta + v_\beta = u_\beta \).
If \(\beta \notin \mathrm{overlappingChecks}(C, L)\), then \((\mathrm{kernelProjection}(C, L)(w))_\beta = 0\) by definition, and \(u_\beta = 0\) since \(u \in \mathrm{OverlappingRowSubspace}(C, L)\).
\((\supseteq )\): Let \(u \in \mathrm{range}(\mathrm{kernelProjection}(C, L))\). Then there exists \(w \in \mathrm{leftKernel}(C)\) such that \(\mathrm{kernelProjection}(C, L)(w) = u\).
First, \(u \in \mathrm{OverlappingRowSubspace}(C, L)\): For \(\beta \notin \mathrm{overlappingChecks}(C, L)\), we have \(u_\beta = (\mathrm{kernelProjection}(C, L)(w))_\beta = 0\) by definition.
Second, define \(v_\beta = w_\beta \) if \(\beta \in \mathrm{nonOverlappingChecks}(C, L)\), and \(v_\beta = 0\) otherwise. Then \(v \in \mathrm{NonOverlappingRowSubspace}(C, L)\) by construction.
Finally, \(u + v = w\): By the check partition theorem, every \(\beta \) is in exactly one of the two check sets. The projection to overlapping coordinates gives \(u\), and the projection to non-overlapping coordinates gives \(v\), so their sum equals \(w\). Since \(w \in \mathrm{leftKernel}(C)\), we have \((u + v) \in \mathrm{leftKernel}(C)\).
As submodules:
By extensionality, for any \(u\), we use Theorem 2749 which establishes the set equality. The forward direction follows from applying the set equality in one direction, and the backward direction follows from applying it in the other direction.
Main Theorem: For a bivariate bicycle code \(C\) measuring logical \(\bar{X}_\alpha \) on left qubits with support \(L\):
Equivalently:
where \(S\) is the submatrix of \(H_Z\) for checks overlapping \(\bar{X}_\alpha \) and \(C\) is the submatrix for non-overlapping checks.
The proof proceeds in three steps:
Step 1: By Theorem 2750, \(\mathrm{range}(\mathrm{kernelProjection}(C, L)) = \mathrm{RedundantCycleSpace}(C, L)\).
Step 2: We establish that \(\dim (\ker (\mathrm{kernelProjection}(C, L))) = \dim (\mathrm{leftKernelNonOverlapping}(C, L))\).
Since \(\mathrm{leftKernelNonOverlapping}(C, L) \leq \mathrm{leftKernel}(C)\) (as the intersection \(\mathrm{NonOverlappingRowSubspace}(C, L) \cap \mathrm{leftKernel}(C)\) is contained in \(\mathrm{leftKernel}(C)\)), we can construct a linear equivalence between \(\ker (\mathrm{kernelProjection}(C, L))\) and \(\mathrm{leftKernelNonOverlapping}(C, L)\).
The forward map sends \(x \in \ker (\mathrm{kernelProjection}(C, L))\) to \((x, \text{proof that } x \in \mathrm{leftKernelNonOverlapping})\), using Theorem 2748.
The inverse map sends \((w, hw) \in \mathrm{leftKernelNonOverlapping}(C, L)\) to \((w, \text{proof that } w \in \ker (\mathrm{kernelProjection}))\), again using Theorem 2748.
Both compositions are the identity by reflexivity.
Step 3: By the rank-nullity theorem for linear maps:
Substituting the results from Steps 1 and 2, we obtain:
The overlapping checks form a subset of all checks:
This follows directly from the fact that any finite set is a subset of the universal finite set.
The non-overlapping checks form a subset of all checks:
This follows directly from the fact that any finite set is a subset of the universal finite set.
The cardinalities satisfy:
By Theorem 2732, the overlapping and non-overlapping checks partition all checks. By Theorem 2733, they are disjoint. Therefore, by the cardinality formula for disjoint unions:
Since the union equals the universal set \(\mathrm{Fin}(\ell ) \times \mathrm{Fin}(m)\), and this has cardinality \(\ell \cdot m\), the result follows.
If the logical support is empty, then no checks overlap:
By extensionality, we show no \(\beta \) is in the overlapping checks. By simplification using the definitions, a check \(\beta \) overlaps if and only if there exists some index in the support of \(B^T\) such that the corresponding shifted index is in the logical support. But the logical support is empty, so no such index exists.
The redundant cycle dimension is bounded by the check space dimension:
The dimension of any submodule is at most the dimension of the ambient module. The check row space has dimension equal to \(|\mathrm{Fin}(\ell ) \times \mathrm{Fin}(m)| = \ell \cdot m\).
When no checks overlap, the redundant cycle space is trivial:
By extensionality, we show \(u \in \mathrm{RedundantCycleSpace}(C, L)\) if and only if \(u = 0\).
\((\Rightarrow )\): Let \(u \in \mathrm{RedundantCycleSpace}(C, L)\). Then \(u \in \mathrm{OverlappingRowSubspace}(C, L)\). By extensionality, for any \(\beta \), we consider whether \(\beta \in \mathrm{overlappingChecks}(C, L)\). Since \(\mathrm{overlappingChecks}(C, L) = \emptyset \), we have \(\beta \notin \mathrm{overlappingChecks}(C, L)\) for all \(\beta \). By the definition of the overlapping row subspace, \(u_\beta = 0\) for all such \(\beta \). Hence \(u = 0\).
\((\Leftarrow )\): If \(u = 0\), then \(u\) is the zero element of the submodule, which is always a member.
For any \(u \in \mathrm{CheckRowSpace}\):
By the definition of the overlapping row subspace, we need to show that for \(\beta \notin \mathrm{overlappingChecks}(C, L)\), \((\mathrm{projToOverlapping}(C, L)(u))_\beta = 0\). By the definition of the projection, this coordinate equals \(0\) when \(\beta \notin \mathrm{overlappingChecks}(C, L)\).
For any \(u \in \mathrm{CheckRowSpace}\):
By the definition of the non-overlapping row subspace, we need to show that for \(\beta \notin \mathrm{nonOverlappingChecks}(C, L)\), \((\mathrm{projToNonOverlapping}(C, L)(u))_\beta = 0\). By the definition of the projection, this coordinate equals \(0\) when \(\beta \notin \mathrm{nonOverlappingChecks}(C, L)\).
The left kernel is a submodule of the check row space:
This holds by reflexivity, taking \(S = \mathrm{leftKernel}(C)\).
The redundant cycle space is contained in the overlapping subspace:
Let \(u \in \mathrm{RedundantCycleSpace}(C, L)\). By the definition of the redundant cycle space, the first component of the membership condition is that \(u \in \mathrm{OverlappingRowSubspace}(C, L)\).
If \(u \in \mathrm{OverlappingRowSubspace}(C, L)\), \(v \in \mathrm{NonOverlappingRowSubspace}(C, L)\), and \((u + v) \in \mathrm{leftKernel}(C)\), then the product of checks indexed by \(u\) and \(v\) has support only on edge qubits. Specifically:
This follows directly from the hypothesis that \((u + v) \in \mathrm{leftKernel}(C)\), which by definition means exactly that \(\sum _\beta (u + v)_\beta \cdot (H_Z)_{\beta ,q} = 0\) for all qubits \(q\).
For \(u \in \mathrm{RedundantCycleSpace}(C, L)\), there exists \(v \in \mathrm{NonOverlappingRowSubspace}(C, L)\) such that \((u + v) \in \mathrm{leftKernel}(C)\) and the edge support of the product of checks (when \(uS + vC = 0\)) forms a cycle in the gauging graph.
Let \(u \in \mathrm{RedundantCycleSpace}(C, L)\). By the definition of the redundant cycle space, we obtain \(u \in \mathrm{OverlappingRowSubspace}(C, L)\) and there exists \(v \in \mathrm{NonOverlappingRowSubspace}(C, L)\) with \((u + v) \in \mathrm{leftKernel}(C)\).
We take this \(v\) as our witness. By Theorem 2762 applied to \(u\), \(v\), and the kernel membership, we conclude that \(\sum _\beta (u + v)_\beta \cdot (H_Z)_{\beta ,q} = 0\) for all qubits \(q\).
1.24 Gross Code Redundant Cycles (Corollary 2)
This section characterizes the cycle structure of the gauging graph for the Gross code \([[144, 12, 12]]\). For the logical operator \(\bar{X}_\alpha \) with weight 12, the gauging graph \(G\) with 12 vertices and 22 edges has:
Cycle rank: \(22 - 12 + 1 = 11\)
Redundant cycles: 4
Independent flux checks needed: \(11 - 4 = 7\)
1.24.1 Gross Code Logical Support
The logical support for \(\bar{X}_\alpha \) in the Gross code is the set of 12 monomial indices where the logical \(X\) acts on left qubits, corresponding to the polynomial
The logical support for the Gross code has exactly 12 elements, matching the weight of the polynomial \(f\).
By unfolding the definition of grossLogicalSupport, this follows directly from the weight computation of logicalXPolyF.
The weight of the Gross code logical operator is 12.
By unfolding the definitions of LeftLogicalSupport.weight and grossLogicalSupport, this follows directly from logicalXPolyF_weight.
1.24.2 Cycle Rank Computation
The cycle rank formula for connected graphs applied to the Gross code gauging graph:
where \(|E|\) is the number of edges and \(|V|\) is the number of vertices.
The number of vertices in the Gross code gauging graph is 12, corresponding to the monomials in the logical operator \(f\).
The number of edges in the Gross code gauging graph is 22, consisting of 18 matching edges and 4 expansion edges.
The gauging graph parameters (12 vertices, 22 edges) match those established in Proposition 1.
Both equalities hold by reflexivity, as the definitions are identical.
The cycle rank of the Gross code gauging graph is defined by the formula:
The cycle rank of the Gross code gauging graph is 11.
We unfold the definition of GrossCodeGaugingGraph.cycleRank, rewrite using the cycle rank formula, and then compute numerically: \(22 - 12 + 1 = 11\).
The cycle rank satisfies the standard formula for connected graphs:
By unfolding the definition of GrossCodeGaugingGraph.cycleRank and rewriting with the cycle rank formula definition.
The computed cycle rank matches the value established in Proposition 1.
By unfolding both definitions, they are definitionally equal.
1.24.3 Independent Cycles
The number of independent flux checks for the Gross code gauging graph is 7. These are proven to be linearly independent over \(\mathbb {F}_2\) in Proposition 1.
The 7 flux cycles are linearly independent over \(\mathbb {F}_2\). This is proven using Mathlib’s LinearIndependent by the unique edge criterion.
This follows directly from grossFluxCycles_linearIndependent established in Proposition 1.
The number of independent cycles equals the length of the flux cycle list, which is 7.
This holds by reflexivity.
The number of independent flux checks matches the value established in Proposition 1.
This holds by reflexivity.
1.24.4 Redundant Cycle Derivation
The number of redundant cycles in the Gross code gauging graph is defined as:
This represents the dimension of the quotient space \((\text{cycle space}) / (\text{span of independent flux cycles})\).
The mathematical justification is:
The cycle space has dimension 11 (from \(|E| - |V| + 1 = 22 - 12 + 1\))
We have 7 linearly independent cycles (proven via Mathlib’s LinearIndependent)
The remaining cycles form a 4-dimensional redundant subspace
Connection to Lemma 10: This count also equals \(\text{row\_ nullity}(H_Z) - \text{row\_ nullity}(C)\) by the BB code redundancy formula.
The redundant cycle count equals 4.
We unfold the definitions of GrossCodeGaugingGraph.redundantCycles and GrossCodeGaugingGraph.independentFluxChecks, rewrite using the fact that the cycle rank is 11, and then verify by computation: \(11 - 7 = 4\).
The redundant cycles are derived from cycle rank minus independent count:
Rewriting using gross_redundant_eq_4 and gross_cycle_rank_eq_11, then unfolding GrossCodeGaugingGraph.independentFluxChecks, the equality \(4 = 11 - 7\) follows by numerical computation.
The fundamental decomposition holds:
That is, \(11 = 4 + 7\).
Rewriting using gross_redundant_eq_4 and gross_cycle_rank_eq_11, then unfolding GrossCodeGaugingGraph.independentFluxChecks, the equality \(11 = 4 + 7\) follows by numerical computation.
1.24.5 Connection to Lemma 10 Framework
The full row nullity of \(H_Z\) for the Gross code, which is the dimension of the left kernel of \(H_Z\).
The row nullity of the non-overlapping check submatrix \(C\) for the Gross code.
The redundant cycle dimension from Lemma 10 for the Gross code.
Lemma 10 instantiation: The BB code redundancy formula applies to the Gross code:
This shows the Lemma 10 framework is applicable. The specific nullity values are determined by \(\mathbb {F}_2\) matrix rank computations.
By unfolding the definitions of grossRedundantCycleDimLem10, grossRowNullityC, and grossFullRowNullity, this follows directly from the redundant_cycles_formula applied to the Gross code and grossLogicalSupport.
The redundant cycle space structure from Lemma 10 is well-defined for the Gross code. There exists a submodule \(R\) of the check row space such that \(R = \text{RedundantCycleSpace}(\text{GrossCode}, \text{grossLogicalSupport})\).
We exhibit the redundant cycle space itself as a witness, establishing the existence by reflexivity.
1.24.6 Main Theorem
Complete characterization of the Gross code gauging graph cycle structure.
For the \([[144, 12, 12]]\) Gross code with logical \(\bar{X}_\alpha \) (weight 12):
The gauging graph has 12 vertices and 22 edges
Cycle rank \(= 22 - 12 + 1 = 11\) (proven via formula)
Independent flux checks \(= 7\) (proven via \(\mathbb {F}_2\) linear independence)
Redundant cycles \(= \text{cycle\_ rank} - \text{independent} = 11 - 7 = 4\) (derived)
What is fully proven in Lean:
Graph parameters (12 vertices, 22 edges) from explicit construction
Cycle rank \(= 11\) from Euler formula for connected graphs
7 cycles are linearly independent over \(\mathbb {F}_2\) (via Mathlib’s LinearIndependent)
Redundant count \(= 4\) derived from (cycle_rank \(-\) independent)
The Lemma 10 framework applies (redundant_cycles_formula instantiated)
We construct the conjunction by providing each component:
\(\text{numVertices} = 12\): by reflexivity
\(\text{numEdges} = 22\): by reflexivity
\(\text{cycleRank} = 11\): by gross_cycle_rank_eq_11
\(\text{independentFluxChecks} = 7\): by reflexivity
Linear independence of flux cycles: by grossFluxCycles_linearIndependent
\(\text{redundantCycles} = 4\): by gross_redundant_eq_4
Derivation formula: by gross_redundant_is_derived
Decomposition: by gross_cycle_decomposition
1.24.7 Connection to Gross Code Parameters
The logical operator weight is 12, which matches the number of vertices in the gauging graph.
Rewriting using logicalXPolyF_weight, both sides evaluate to 12.
The Gross code distance is 12, which matches the logical operator weight.
Rewriting using logicalXPolyF_weight, both sides equal 12.
By unfolding grossCodeParams, all three equalities are verified by computation.
1.24.8 Overhead Analysis
The total overhead for gauging consists of \(X\) checks, \(Z\) checks, and qubits:
By unfolding the definitions of numVertices (12), independentFluxChecks (7), and numEdges (22), the sum \(12 + 7 + 22 = 41\) follows by numerical computation.
The overhead calculation matches the value established in Proposition 1.
Rewriting using grossTotalOverhead_eq, this follows directly from gross_total_overhead.
1.24.9 Cycle Space Dimension Properties
The cycle space has dimension 11 (the cycle rank for a connected graph).
This follows directly from gross_cycle_rank_eq_11.
The flux check space has dimension 7 (the number of independent checks).
This holds by reflexivity.
The redundant subspace has dimension 4 (derived from cycle rank minus independent).
This follows directly from gross_redundant_eq_4.
The 7 flux cycles are linearly independent over \(\mathbb {F}_2\).
This follows directly from grossFluxCycles_linearIndependent imported from Proposition 1.
1.24.10 Cycle Rank Non-negativity
The cycle rank is non-negative: \(0 \le \text{cycleRank}\).
Rewriting using gross_cycle_rank_eq_11, we have \(0 \le 11\) by numerical computation.
The gauging graph is not a tree, since its cycle rank is positive: \(0 {\lt} \text{cycleRank}\).
Rewriting using gross_cycle_rank_eq_11, we have \(0 {\lt} 11\) by numerical computation.
The graph has 11 more edges than a spanning tree would have:
By unfolding numEdges (22) and numVertices (12), the equality \(22 - 11 = 11\) follows by numerical computation.
1.24.11 Summary Helper Lemmas
Summary of all numerical values:
\(\text{numVertices} = 12\)
\(\text{numEdges} = 22\)
\(\text{cycleRank} = 11\)
\(\text{redundantCycles} = 4\)
\(\text{independentFluxChecks} = 7\)
All values follow from reflexivity except cycleRank (from gross_cycle_rank_eq_11) and redundantCycles (from gross_redundant_eq_4).
The cycle rank formula holds for these specific values:
By numerical computation.
The decomposition formula holds for these specific values:
By numerical computation.
The number of independent flux checks can be computed from the cycle rank and redundant cycles:
Rewriting using gross_cycle_rank_eq_11 and gross_redundant_eq_4, then unfolding independentFluxChecks, the equality \(7 = 11 - 4\) follows by numerical computation.
The number of redundant cycles can be computed from the cycle rank and independent flux checks:
Rewriting using gross_cycle_rank_eq_11 and gross_redundant_eq_4, then unfolding independentFluxChecks, the equality \(4 = 11 - 7\) follows by numerical computation.
1.24.12 Row Nullity Background
For a \([[n, k, d]]\) BB code:
Total physical qubits: \(n = 2 \cdot \ell \cdot m\)
Total checks: \(2 \cdot \ell \cdot m\) (72 X-checks + 72 Z-checks for Gross)
\(\text{rank}(H_Z) = \text{rank}(H_X) = (n - k)/2\) by CSS code theory
\(\text{row\_ nullity}(H_Z) = \ell \cdot m - \text{rank}(H_Z)\) in the monomial index space
For Gross code \([[144, 12, 12]]\):
\(n = 144\), \(k = 12\), so \(\text{rank}(H_Z) = (144 - 12)/2 = 66\)
\(\ell \cdot m = 72\), so \(\text{row\_ nullity}(H_Z) = 72 - 66 = 6\) (counting row dependencies)
For the Gross code, the CSS rank formula gives:
By unfolding grossCodeParams, the computation \((144 - 12) / 2 = 66\) follows numerically.
The monomial space dimension for the Gross code is:
By computation.
The number of row dependencies in \(H_Z\) for the Gross code is:
By unfolding grossCodeParams, GrossCode.ell, and GrossCode.m, the computation \(72 - 66 = 6\) follows numerically.
1.24.13 Legacy Compatibility
Legacy theorem for backward compatibility, collecting all main results:
\(\text{numVertices} = 12\)
\(\text{numEdges} = 22\)
\(\text{cycleRank} = 11\)
\(\text{cycleRank} = |E| - |V| + 1\)
\(\text{redundantCycles} = 4\)
\(\text{independentFluxChecks} = 7\)
\(\text{cycleRank} = \text{redundantCycles} + \text{independentFluxChecks}\)
We construct the conjunction by providing:
Vertices = 12, Edges = 22: by reflexivity
Cycle rank = 11: by gross_cycle_rank_eq_11
Formula equality: by gross_cycle_rank_formula
Redundant = 4: by gross_redundant_eq_4
Independent = 7: by reflexivity
Decomposition: by gross_cycle_decomposition
[Decoder Requirements]
Decoding the fault-tolerant gauging measurement requires handling several types of syndromes:
Syndrome types:
\(A_v\) syndromes: Created by \(Z\) errors on vertex and edge qubits
\(B_p\) syndromes: Created by \(X\) errors on edge qubits
\(\tilde{s}_j\) syndromes: Created by both \(X\) and \(Z\) errors on vertex and edge qubits
Decoder approaches:
General-purpose: Belief propagation with ordered statistics post-processing (BP+OSD)
Structured: Matching on \(A_v\) syndromes (similar to surface code), combined with code-specific decoding for \(\tilde{s}_j\)
Open question: Designing decoders that exploit the structure of the gauging measurement for improved performance.
No proof needed for remarks.
Classification of syndrome types in the gauging measurement:
\(A_v\): syndrome from Gauss law operators (created by \(Z\) errors)
\(B_p\): syndrome from flux operators (created by \(X\) errors)
\(\tilde{s}_j\): syndrome from deformed checks (created by both \(X\) and \(Z\) errors)
There are exactly 3 syndrome types: \(|\texttt{SyndromeType}| = 3\).
This holds by reflexivity (the definition directly yields cardinality 3).
Classification of qubit locations:
vertex: vertex qubits
edge: edge qubits
An error specification consists of:
location: the qubit location (vertex or edge)
pauliType: the type of Pauli error (\(X\) or \(Z\))
The number of error specifications is \(2 \times 2 = 4\) (2 locations \(\times \) 2 Pauli types).
This holds by reflexivity from the explicit enumeration of all four combinations.
The predicate \(\texttt{errorsCreateSyndrome}(e, s)\) determines whether an error type \(e\) creates a syndrome of type \(s\):
\(A_v\) (X-type operator): anticommutes with \(Z\) errors on both vertex and edge qubits
\(B_p\) (Z-type operator on edges): anticommutes with \(X\) errors on edge qubits only
\(\tilde{s}_j\) (general stabilizer): anticommutes with all error types
\(A_v\) syndromes are created by \(Z\) errors on vertex and edge qubits:
\(Z\) on vertex creates \(A_v\) syndrome
\(Z\) on edge creates \(A_v\) syndrome
\(X\) on vertex does NOT create \(A_v\) syndrome
\(X\) on edge does NOT create \(A_v\) syndrome
This is because \(A_v\) is an X-type operator, which anticommutes with \(Z\).
By unfolding the definition of errorsCreateSyndrome, each case reduces to either True (for Z errors) or False (for X errors) by pattern matching. The result follows directly: the first two conditions are trivially true, and the latter two hold because \(h \Rightarrow h\) shows the negations hold.
\(B_p\) syndromes are created by \(X\) errors on edge qubits:
\(X\) on edge creates \(B_p\) syndrome
\(Z\) on edge does NOT create \(B_p\) syndrome
\(X\) on vertex does NOT create \(B_p\) syndrome (\(B_p\) doesn’t involve vertices)
\(Z\) on vertex does NOT create \(B_p\) syndrome
This is because \(B_p\) is a Z-type operator on edges, which anticommutes with \(X\) on edges.
By unfolding the definition of errorsCreateSyndrome, the first condition is trivially true (X on edge with \(B_p\)), and the remaining three conditions hold because each reduces to showing \(h \Rightarrow h\) which proves the negations.
\(\tilde{s}_j\) syndromes are created by both \(X\) and \(Z\) errors on both vertex and edge qubits. All four error types create \(\tilde{s}_j\) syndromes. This is because \(\tilde{s}_j\) are general stabilizers (typically mixed X/Z type).
By unfolding the definition of errorsCreateSyndrome, for \(\tilde{s}_j\) syndrome type, all cases (any location, any Pauli type) evaluate to True. The result follows by providing four trivial proofs.
Complete characterization of which errors affect which syndromes:
\(A_v\): only \(Z\) errors (for all locations, \(Z\) creates \(A_v\); for all locations, \(X\) does not)
\(B_p\): only \(X\) on edges (for all locations, \(Z\) does not create \(B_p\); \(X\) on vertex does not)
\(\tilde{s}_j\): all errors (for all locations and Pauli types, the error creates \(\tilde{s}_j\))
We prove each part separately:
For \(Z\) errors on \(A_v\): by case analysis on location, both vertex and edge cases are trivially true.
For \(X\) errors on \(A_v\): by case analysis on location, both cases require showing \(h \Rightarrow h\).
\(X\) on edge creates \(B_p\): trivially true.
For \(Z\) errors on \(B_p\): by case analysis on location, both require \(h \Rightarrow h\).
\(X\) on vertex does not create \(B_p\): requires \(h \Rightarrow h\).
For \(\tilde{s}_j\): by case analysis on location and Pauli type, all four cases are trivially true.
Classification of decoder approaches:
generalPurpose: Belief propagation + OSD post-processing
structured: Matching on \(A_v\) (like surface code) + code-specific for \(\tilde{s}_j\)
There are exactly 2 decoder approaches: \(|\texttt{DecoderApproach}| = 2\).
This holds by reflexivity from the explicit enumeration.
Properties of each decoder approach:
handles_Av: can handle \(A_v\) syndromes
handles_Bp: can handle \(B_p\) syndromes
handles_Stilde: can handle \(\tilde{s}_j\) syndromes
exploits_structure: uses code structure
General-purpose (BP+OSD) decoder specification:
handles_Av = true
handles_Bp = true
handles_Stilde = true
exploits_structure = false (treats code as generic linear code)
Structured decoder specification:
handles_Av = true (via matching, like surface code)
handles_Bp = true
handles_Stilde = true (via code-specific decoding)
exploits_structure = true
Both decoder approaches can handle all syndrome types:
generalPurposeSpec.handles_Av = true
generalPurposeSpec.handles_Bp = true
generalPurposeSpec.handles_Stilde = true
structuredSpec.handles_Av = true
structuredSpec.handles_Bp = true
structuredSpec.handles_Stilde = true
All six equalities hold by reflexivity, as each is directly specified in the definition of the respective specification.
The structured decoder exploits code structure while the general-purpose does not:
structuredSpec.exploits_structure = true
generalPurposeSpec.exploits_structure = false
Both equalities hold by reflexivity from the definitions.
A syndrome configuration specifies which detectors are violated:
violatedAv: set of violated \(A_v\) detectors (by vertex index)
violatedBp: set of violated \(B_p\) detectors (by plaquette index)
violatedStilde: set of violated \(\tilde{s}_j\) detectors (by check index)
The empty syndrome configuration has no violations: all three violation sets are empty.
The total number of violated detectors in a syndrome configuration \(s\) is:
The empty syndrome has zero violations: \(\texttt{totalViolations}(\texttt{empty}) = 0\).
By simplification using the definitions of empty and totalViolations, each set is empty, so each cardinality is 0, and the sum is 0.
A syndrome is trivial if it has no violations:
The empty syndrome configuration is trivial.
By simplification using the definitions of empty and isTrivial, all three conditions are satisfied since each set is empty.
A syndrome is trivial if and only if it has zero total violations:
We prove both directions:
(\(\Rightarrow \)): Assume \(s.\texttt{violatedAv} = \emptyset \), \(s.\texttt{violatedBp} = \emptyset \), and \(s.\texttt{violatedStilde} = \emptyset \). By simplification, each cardinality is 0, so the sum is 0.
(\(\Leftarrow \)): Assume \(\texttt{totalViolations}(s) = 0\). Since all cardinalities are non-negative and their sum is 0, by integer arithmetic (omega), each cardinality must be 0. By the fact that a finite set has cardinality 0 iff it is empty, all three sets are empty.
A recovery operation specification (abstract) consisting of:
id: identifier for the recovery
weight: weight of the recovery (number of Pauli operators)
Decoder requirements specification:
approach: the decoder approach used
maxSyndromeSize: maximum syndrome size the decoder can handle
findsMWE: whether decoder is guaranteed to find minimum weight recovery
runtimeDegree: expected runtime complexity (encoded as degree of polynomial)
BP+OSD decoder requirements:
approach = generalPurpose
maxSyndromeSize = 0 (no explicit limit, depends on implementation)
findsMWE = false (BP+OSD is approximate)
runtimeDegree = 3 (typically \(O(n^3)\) for OSD)
Matching-based decoder requirements:
approach = structured
maxSyndromeSize = 0 (no explicit limit)
findsMWE = true (matching finds MWE for \(A_v\), like surface code)
runtimeDegree = 3 (\(O(n^3)\) for minimum weight matching)
BP+OSD is a general-purpose decoder: \(\texttt{bpOsdRequirements.approach} = \texttt{generalPurpose}\).
This holds by reflexivity from the definition.
Matching is a structured decoder: \(\texttt{matchingRequirements.approach} = \texttt{structured}\).
This holds by reflexivity from the definition.
\(A_v\) syndrome has matching structure similar to surface code:
violations: the set of violated \(A_v\) locations
even_cardinality: violations come in pairs (even cardinality) for closed chains
The empty violation set has even cardinality: \(|\emptyset | = 0\) is even.
By simplification, \(|\emptyset | = 0\), and \(0 = 2 \cdot 0\) witnesses that 0 is even.
The empty \(A_v\) matching structure with no violations.
If \(S\) has even cardinality and \(v_1, v_2 \notin S\) with \(v_1 \neq v_2\), then \(|S \cup \{ v_1, v_2\} |\) is even.
Let \(S\) have even cardinality, say \(|S| = 2k\), and let \(v_1, v_2 \notin S\) with \(v_1 \neq v_2\). We show \(v_1 \neq v_2\) implies \(v_1 \notin \{ v_2\} \). Then \(|\{ v_1, v_2\} | = 2\) by inserting \(v_1\) into the singleton \(\{ v_2\} \). Since \(S\) and \(\{ v_1, v_2\} \) are disjoint (any element of \(S\) differs from both \(v_1\) and \(v_2\) by hypothesis), we have \(|S \cup \{ v_1, v_2\} | = |S| + 2 = 2k + 2 = 2(k+1)\), which is even.
A matching result is a finite set of pairs \(\mathbb {N} \times \mathbb {N}\), representing matched violation pairs.
A valid matching pairs all violations: for each violation \(v\), there exists a unique pair \(p\) in the matching such that \(p.1 = v\) or \(p.2 = v\).
Relative complexity of decoding different syndrome types:
\(A_v \mapsto 1\) (Simple: matching, like surface code)
\(B_p \mapsto 2\) (Medium: cycle structure)
\(\tilde{s}_j \mapsto 3\) (Complex: general code structure)
\(A_v\) is the simplest syndrome type (matchable like surface code):
By simplification using the definition of syndromeComplexity, we have \(1 \leq 2\) and \(1 \leq 3\). Both inequalities follow by integer arithmetic (omega).
\(B_p\) has intermediate complexity:
By simplification using the definition of syndromeComplexity, we have \(1 \leq 2\) and \(2 \leq 3\). Both inequalities follow by integer arithmetic (omega).
A decoder exploits gauging structure if it uses:
usesGraphStructure: the graph structure of \(G\)
usesSyndromeRelations: the relationship between \(A_v\), \(B_p\), and \(\tilde{s}_j\)
usesCycleStructure: the cycle structure of \(B_p\) operators
Full structure exploitation: all three properties are true.
No structure exploitation (black-box decoder): all three properties are false.
The open question: can we do better by exploiting structure? Formally:
The three syndrome types are pairwise distinct:
We prove each inequality separately. For each, we assume equality and derive a contradiction by case analysis (the cases tactic on an equality of distinct constructors yields no cases to consider).
Each error type affects at least one syndrome type. Specifically, for any error specification \(e\), there exists a syndrome type \(s\) such that \(\texttt{errorsCreateSyndrome}(e, s)\).
We show that \(\tilde{s}_j\) is always affected. By unfolding errorsCreateSyndrome, for any location and Pauli type, the case for \(\tilde{s}_j\) evaluates to True. The witness is \(\tilde{s}_j\), and by case analysis on location and Pauli type, all cases are trivially true.
\(Z\) errors affect \(A_v\) but not \(B_p\): for any location,
We prove both conjuncts:
For \(A_v\): by case analysis on location, both vertex and edge cases are trivially true.
For \(B_p\): by case analysis on location, both cases require showing \(h \Rightarrow h\) to establish the negation.
\(X\) errors on edges affect \(B_p\) but not \(A_v\):
Both conjuncts are trivially true by the definition of errorsCreateSyndrome: \(X\) on edge with \(B_p\) evaluates to True, and \(X\) on edge with \(A_v\) evaluates to False.
\(|\texttt{DecoderApproach}| = 2\).
This holds by reflexivity from the explicit enumeration.
\(|\texttt{SyndromeType}| = 3\).
This holds by reflexivity from the explicit enumeration.
\(|\texttt{ErrorSpec}| = 4\).
This holds by reflexivity from the explicit enumeration.
[Comparison to Prior Work]
This remark compares qubit overhead for logical measurement schemes across three approaches:
Cohen et al. [ : Overhead \(\Theta (Wd)\) where \(W\) is the logical weight and \(d\) is the code distance. For good codes with \(d = \Theta (n)\): overhead \(\Theta (n^2)\).
Cross et al. [ : Overhead \(\Theta (W)\) when:
Sufficient expansion in the logical’s Tanner subgraph
Low-weight auxiliary gauge-fixing checks exist
This work (gauging measurement): Overhead \(O(W \log ^2 W)\)
Always achievable via cycle-sparsification
Often better in practice (e.g., Gross code: 41 vs larger overhead for prior methods)
Key advantage: The flexibility in choosing the gauging graph \(G\) allows optimization for specific code instances.
No proof needed for remarks.
The overhead structure for the Cohen et al. measurement scheme uses \(d\) layers of dummy qubits for each qubit in \(\operatorname {supp}(L)\). The structure consists of:
Logical weight \(W = |\operatorname {supp}(L)|\) (positive)
Code distance \(d\) (positive)
The Cohen overhead formula is \(W \times d\).
For any Cohen overhead structure \(C\), the overhead \(C.\text{overhead} {\gt} 0\).
The overhead equals \(W \times d\) where both \(W {\gt} 0\) and \(d {\gt} 0\) by the structure constraints. By the positivity of multiplication of positive naturals, \(W \times d {\gt} 0\).
For a Cohen overhead structure \(C\), if \(W = c_1 n\) and \(d = c_2 n\) for constants \(c_1, c_2\), then the overhead equals \(c_1 c_2 n^2\).
By definition, the overhead is \(W \times d\). Substituting \(W = c_1 n\) and \(d = c_2 n\), we get \((c_1 n)(c_2 n) = c_1 c_2 n^2\) by ring arithmetic.
The overhead structure for the Cross et al. measurement scheme achieves linear overhead when expansion conditions hold. The structure consists of:
Logical weight \(W = |\operatorname {supp}(L)|\) (positive)
Expansion constant \(c\) (positive)
The Cross overhead formula is \(c \times W\) (linear in \(W\)).
For any Cross overhead structure \(X\), the overhead \(X.\text{overhead} {\gt} 0\).
The overhead equals \(c \times W\) where both \(c {\gt} 0\) and \(W {\gt} 0\) by the structure constraints. By positivity of multiplication, \(c \times W {\gt} 0\).
For any Cross overhead structure \(X\), the overhead satisfies \(X.\text{overhead} \leq c \times W\), i.e., it is \(O(W)\).
This holds by reflexivity since the overhead is defined as \(c \times W\).
The overhead structure for the gauging measurement scheme achieves \(O(W \log ^2 W)\) via cycle-sparsification (Freedman-Hastings). The structure consists of:
Logical weight \(W = |\operatorname {supp}(L)|\) with \(W \geq 2\)
The gauging overhead formula is \(W \times (\log _2^2 W + 2)\).
The gauging overhead equals the general overhead bound formula: \(G.\text{overhead} = \text{overheadBound}(W)\).
This holds by reflexivity of the definition.
For any gauging overhead structure \(G\), the overhead \(G.\text{overhead} {\gt} 0\).
The overhead is \(W \times (\log _2^2 W + 2)\). Since \(W \geq 2\) by assumption, we have \(W {\gt} 0\). Also, \(\log _2^2 W + 2 \geq 2 {\gt} 0\). Therefore, the product is positive by multiplication of positive naturals.
For any gauging overhead structure \(G\), \(W \leq G.\text{overhead}\).
Since \(\log _2^2 W + 2 \geq 1\), we have:
A configuration for comparing overhead methods, consisting of:
Logical weight \(W\) with \(W \geq 4\)
Code distance \(d {\gt} 0\)
For an overhead comparison \(O\), if \(d {\gt} \log _2^2 W + 2\), then the gauging overhead is strictly less than the Cohen overhead:
The gauging overhead is \(W \times (\log _2^2 W + 2)\) and the Cohen overhead is \(W \times d\). Since \(d {\gt} \log _2^2 W + 2\) and \(W \geq 4 {\gt} 0\), by the property that \(W \cdot a {\lt} W \cdot b\) when \(a {\lt} b\) and \(W {\gt} 0\), we conclude \(W \times (\log _2^2 W + 2) {\lt} W \times d\).
For good codes with \(d = c \times W\) (distance linear in weight), the Cohen overhead is \(\Theta (W^2)\):
By definition, Cohen overhead is \(W \times d\). Substituting \(d = c \times W\), we get \(W \times (c \times W) = c \cdot W^2\) by ring arithmetic.
The gauging overhead is \(O(W \log ^2 W)\) regardless of the code distance \(d\):
This holds by reflexivity of the definition.
The Gross code parameters for comparison:
Logical weight \(W = 12\)
Code distance \(d = 12\)
Optimal gauging auxiliary count is 41
For the Gross code, the Cohen overhead is \(12 \times 12 = 144\).
By definition, the Cohen overhead is \(W \times d = 12 \times 12 = 144\). This is verified by computation.
For the Gross code, the actual gauging count (41) is strictly less than the Cohen overhead (144):
The gauging actual count is 41 and the Cohen overhead is 144. Since \(41 {\lt} 144\), this is verified by computation.
Gauging saves 103 auxiliary qubits compared to Cohen for the Gross code:
By computation: \(144 - 41 = 103\).
Cohen uses about \(3.5\times \) more auxiliary qubits: \(\frac{144}{41} {\gt} 3\).
By numerical computation, \(\frac{144}{41} \approx 3.51 {\gt} 3\).
The flexibility in gauging graph choice:
Number of possible gauging graph choices \(n {\gt} 0\)
Overhead achievable for each choice: a function from \(\{ 0, \ldots , n-1\} \) to \(\mathbb {N}\)
For any gauging flexibility \(F\), there exists a choice \(i\) such that \(F.\text{overheadForChoice}(i) \geq 0\).
We take \(i = 0\) (which exists since \(n {\gt} 0\)). Since overhead values are natural numbers, \(F.\text{overheadForChoice}(0) \geq 0\) holds trivially.
For any gauging flexibility \(F\) and choice \(i\), \(F.\text{minOverhead} \leq F.\text{overheadForChoice}(i)\).
This follows from the definition of \(\inf '\) over a finite set: the infimum is at most any element in the set.
For any gauging flexibility \(F\) and choice \(i\), \(F.\text{overheadForChoice}(i) \leq F.\text{maxOverhead}\).
This follows from the definition of \(\sup '\) over a finite set: any element is at most the supremum.
For any gauging flexibility \(F\), \(F.\text{minOverhead} \leq F.\text{maxOverhead}\).
Classification of measurement methods:
cohen: Cohen et al. with \(\Theta (Wd)\) overhead
cross: Cross et al. with \(\Theta (W)\) overhead (when conditions hold)
gauging: This work with \(O(W \log ^2 W)\) overhead (always achievable)
The overhead function for each method given weight \(W\) and distance \(d\):
For \(W {\gt} 0\) and \(d_1 {\lt} d_2\):
The Cohen overhead is \(W \times d\). Since \(d_1 {\lt} d_2\) and \(W {\gt} 0\), we have \(W \times d_1 {\lt} W \times d_2\) by the strict monotonicity of multiplication with a positive factor.
For any \(W, d_1, d_2\):
This holds by reflexivity since the gauging overhead formula \(W \times (\log _2^2 W + 2)\) does not depend on \(d\).
For \(W \geq 4\) and \(d {\gt} \log _2^2 W + 2\):
\(\text{methodOverhead}(\text{cross}, W, d) {\lt} \text{methodOverhead}(\text{cohen}, W, d)\)
\(\text{methodOverhead}(\text{cross}, W, d) {\lt} \text{methodOverhead}(\text{gauging}, W, d)\)
For the first inequality: The Cross overhead is \(W\) and the Cohen overhead is \(W \times d\). Since \(d {\gt} \log _2^2 W + 2 \geq 2\), we have \(d {\gt} 1\), so \(W = W \times 1 {\lt} W \times d\).
For the second inequality: Since \(W \geq 4\), we have \(\log _2 W \geq \log _2 4 = 2\). Thus \((\log _2 W)^2 \geq 4\), so \((\log _2 W)^2 + 2 {\gt} 1\). Since \(W {\gt} 0\), we have \(W = W \times 1 {\lt} W \times ((\log _2 W)^2 + 2)\).
A summary of a method’s characteristics:
The method type
Whether overhead depends on distance \(d\)
Whether special conditions are required
The asymptotic overhead class
The gauging method does not depend on distance: \(\text{gaugingSummary.dependsOnDistance} = \text{false}\).
This holds by reflexivity of the definition.
The gauging method requires no special conditions: \(\text{gaugingSummary.requiresConditions} = \text{false}\).
This holds by reflexivity of the definition.
The Cohen method depends on distance: \(\text{cohenSummary.dependsOnDistance} = \text{true}\).
This holds by reflexivity of the definition.
For \(W {\gt} 0\) and \(d {\gt} \log _2^2 W + 2\):
The gauging overhead is \(W \times (\log _2^2 W + 2)\) and the Cohen overhead is \(W \times d\). Since \(d {\gt} \log _2^2 W + 2\) and \(W {\gt} 0\), by strict monotonicity of multiplication we have \(W \times (\log _2^2 W + 2) {\lt} W \times d\).
When expansion holds: \(\text{methodOverhead}(\text{cross}, W, 1) = W\).
This holds by reflexivity of the definition.
\(\text{methodOverhead}(\text{cohen}, 12, 12) = 144\).
By computation: \(12 \times 12 = 144\).
\(\text{methodOverhead}(\text{gauging}, 12, 12) = 12 \times (9 + 2) = 132\).
We have \(\log _2 12 = 3\) (by computation). Thus:
For the Gross code (\(W = d = 12\)), gauging has smaller overhead than Cohen:
We have \(\log _2 12 = 3\) (by computation). The gauging overhead is \(12 \times (9 + 2) = 132\) and the Cohen overhead is \(12 \times 12 = 144\). Since \(132 {\lt} 144\), the result follows.
For \(d_1 \leq d_2\):
The Cohen overhead is \(W \times d\). Since \(d_1 \leq d_2\), we have \(W \times d_1 \leq W \times d_2\) by monotonicity of multiplication.
For \(W_1 \leq W_2\):
Since \(W_1 \leq W_2\), we have \(\log _2 W_1 \leq \log _2 W_2\) by monotonicity of the logarithm. Thus \((\log _2 W_1)^2 \leq (\log _2 W_2)^2\) by monotonicity of squaring on non-negative numbers. We then compute:
where the first inequality uses \(W_1 \leq W_2\) and the second uses \((\log _2 W_1)^2 \leq (\log _2 W_2)^2\).
For \(W {\gt} 0\), \(c {\gt} 0\), and \(d = c \times W\):
Cohen is \(\Theta (W^2)\): \(\text{methodOverhead}(\text{cohen}, W, d) = c \cdot W^2\)
Gauging is \(O(W \log ^2 W)\): \(\text{methodOverhead}(\text{gauging}, W, d) = W \times ((\log _2 W)^2 + 2)\)
For the first claim: The Cohen overhead is \(W \times d = W \times (c \times W) = c \cdot W^2\) by ring arithmetic.
For the second claim: This holds by reflexivity of the gauging overhead definition.
A BB logical support for a bivariate bicycle code with parameters \(\ell \) and \(m\) is a structure representing the support of a logical operator. It consists of:
A left support \(p\): a BB polynomial representing the left qubit positions
A right support \(q\): a BB polynomial representing the right qubit positions
A logical X operator \(X(p, q)\) acts on left qubits at positions given by polynomial \(p\) and right qubits at positions given by polynomial \(q\).
The zero support is the BB logical support with both left and right supports equal to the zero polynomial (no qubits acted on).
Given a BB polynomial \(p\), the left-only support is the BB logical support with left support \(p\) and right support equal to zero.
Given a BB polynomial \(q\), the right-only support is the BB logical support with left support zero and right support \(q\).
The weight of a BB logical support \(S = (p, q)\) is the total number of qubits acted upon:
where \(|p|\) and \(|q|\) denote the number of terms in the respective polynomials.
The transpose of a BB logical support \(S = (p, q)\) is defined as:
where \(p^T = p(x^{-1}, y^{-1})\) denotes the transpose of the polynomial (replacing each monomial \(x^a y^b\) with \(x^{-a} y^{-b}\)).
This is the key symmetry operation for BB codes: it swaps left and right supports while transposing each polynomial.
For any BB logical support \(S\), the double transpose returns the original support:
By definition, \(S^T = (q^T, p^T)\). Applying transpose again:
This follows by simplification using the fact that polynomial transpose is an involution.
The transpose of the zero support is zero:
By simplification using the definitions of transpose and zero support, together with the fact that the transpose of the zero polynomial is zero.
For any BB polynomial \(p\), the transpose of a left-only support gives a right-only support:
By simplification using the definitions. The left-only support \((p, 0)\) transposes to \((0^T, p^T) = (0, p^T)\), which is the right-only support with polynomial \(p^T\).
For any BB polynomial \(q\), the transpose of a right-only support gives a left-only support:
By simplification using the definitions. The right-only support \((0, q)\) transposes to \((q^T, 0^T) = (q^T, 0)\), which is the left-only support with polynomial \(q^T\).
The overlap count of a support \(S\) with a check polynomial \(P\) at check index \(\alpha = (\alpha _1, \alpha _2)\) is:
In \(\mathbb {F}_2\) arithmetic, the commutation condition requires this count to be even.
The transpose index operation on indices \(\alpha = (a, b) \in \text{Fin}(\ell ) \times \text{Fin}(m)\) is defined as:
where negation is in the respective finite groups.
The transpose index operation is an involution:
By simplification: \(\text{transposeIdx}(\text{transposeIdx}(a, b)) = \text{transposeIdx}(-a, -b) = (--a, --b) = (a, b)\) using the fact that double negation is the identity.
The transpose index of zero is zero:
By simplification: \((-0, -0) = (0, 0)\).
For a BB code \(C\) with \(H_X = [A \mid B]\), the X commutation condition for support \(S = (p, q)\) at check index \(\alpha \) is:
For a BB code \(C\) with \(H_Z = [B^T \mid A^T]\), the Z commutation condition for support \(S = (p, q)\) at check index \(\beta \) is:
The negation map \((a, b) \mapsto (-a, -b)\) on \(\text{Fin}(\ell ) \times \text{Fin}(m)\) is injective.
Let \((a_1, b_1)\) and \((a_2, b_2)\) be such that \((-a_1, -b_1) = (-a_2, -b_2)\). By the injectivity of negation in finite groups, we have \(a_1 = a_2\) and \(b_1 = b_2\). Therefore \((a_1, b_1) = (a_2, b_2)\).
For BB polynomials \(p\) and \(Q\) and index \(\beta \):
This uses the fact that \(k \in p^T.\text{support}\) iff \(-k \in p.\text{support}\), and \((\)β\( + k) \in Q^T.\text{support}\) iff \((-\)β\( - k) \in Q.\text{support}\).
We establish a bijection between the two filtered sets. For the LHS, we filter \(k\) in \(p^T.\text{support}\) such that \((\beta + k) \in Q^T.\text{support}\). For the RHS, we filter \(k'\) in \(p.\text{support}\) such that \((-\beta + k') \in Q.\text{support}\). The bijection is given by \(k \mapsto -k\).
We verify this is well-defined: if \(k \in p^T.\text{support}\), then there exists \(k' \in p.\text{support}\) with \(k = (-k'_1, -k'_2)\), so \(-k = k' \in p.\text{support}\). Similarly for the check polynomial membership.
Injectivity follows from the injectivity of negation. For surjectivity, given \(k'\) in the RHS filter, we take \((-k'_1, -k'_2)\) which maps to \(k'\) under the bijection.
Since we have a bijection between finite sets, their cardinalities are equal.
For a BB code \(C\) with \(H_X = [A \mid B]\) and \(H_Z = [B^T \mid A^T]\):
If support \(S = (p, q)\) commutes with all X-checks (i.e., \(H_X \cdot (p, q)^T = 0\)), then the transposed support \(S^T = (q^T, p^T)\) commutes with all Z-checks (i.e., \(H_Z \cdot (q^T, p^T)^T = 0\)).
Let \(\beta \) be any Z-check index. We need to show the Z commutation condition holds for \(S^T\) at \(\beta \).
By definition, \(S^T = (q^T, p^T)\), so the Z commutation condition is:
Using the overlap transpose equality lemma:
So the condition becomes:
By the hypothesis that \(S\) commutes with all X-checks, taking \(\alpha = -\beta \):
By commutativity of addition, this is exactly what we needed to show.
For a BB code \(C\): if \(S^T\) commutes with all Z-checks, then \(S\) commutes with all X-checks.
Let \(\alpha \) be any X-check index. We specialize the hypothesis to \(\beta = -\alpha \). Using the overlap transpose equality and simplifying (noting that \(--\alpha = \alpha \)), we obtain the X commutation condition at \(\alpha \) by linear arithmetic.
The symplectic inner product in \(\mathbb {F}_2\) for BB logical supports is:
This computes whether an X-type and Z-type operator anticommute (odd result) or commute (even result).
The symplectic inner product is preserved under the transpose symmetry:
We first establish that for any BB polynomials \(A\) and \(B\):
This holds because transpose is a bijection on supports: \(A^T \cap B^T = \text{image}(\text{neg}, A \cap B)\), and the negation map is injective.
For the LHS: \(|p \cap r| + |q \cap s|\).
For the RHS after substitution: \(|s^T \cap q^T| + |r^T \cap p^T| = |s \cap q| + |r \cap p| = |q \cap s| + |p \cap r|\).
By commutativity of intersection and addition, these are equal.
A valid logical X operator for a BB code \(C\) is a structure consisting of:
A support \(S \in \text{BBLogicalSupport}\)
A proof that \(S\) commutes with all X-checks: \(\forall \alpha , \text{XCommutationAt}(C, S, \alpha )\)
A proof that \(S\) commutes with all Z-checks: \(\forall \beta , \text{ZCommutationAt}(C, S, \beta )\)
A valid logical Z operator for a BB code \(C\) is a structure consisting of:
A support \(S \in \text{BBLogicalSupport}\)
A proof that \(S\) commutes with all X-checks: \(\forall \alpha , \text{XCommutationAt}(C, S, \alpha )\)
A proof that \(S\) commutes with all Z-checks: \(\forall \beta , \text{ZCommutationAt}(C, S, \beta )\)
For a BB code \(C\) with \(H_X = [A \mid B]\) and \(H_Z = [B^T \mid A^T]\):
If \(X(p, q)\) is a valid logical X operator (commutes with all stabilizers), then \(Z(q^T, p^T)\) is a valid logical Z operator.
This is the core content of Proposition 4: the symmetry \((p, q) \mapsto (q^T, p^T)\) maps logical X operators to corresponding logical Z operators.
We construct the valid logical Z operator with support \(S^T = (q^T, p^T)\).
X-commutation: We need to show \(S^T\) commutes with all X-checks. We apply the parity check symmetry converse to \(S^T\). This requires showing \((S^T)^T = S\) commutes with all Z-checks, which holds by the original operator’s \(\text{commutes\_ Z}\) property.
Z-commutation: We need to show \(S^T\) commutes with all Z-checks. We apply the parity check symmetry theorem to \(S\). Since \(S\) commutes with all X-checks (by \(\text{commutes\_ X}\)), we conclude \(S^T\) commutes with all Z-checks.
For a BB code \(C\): if \(Z(q^T, p^T)\) is a valid logical Z operator, then \(X(p, q)\) is a valid logical X operator.
We construct the valid logical X operator with support equal to the transpose of the Z operator’s support.
X-commutation: We apply the parity check symmetry converse, using the double transpose property and the Z operator’s commutes_Z property.
Z-commutation: We apply the parity check symmetry theorem to the Z operator’s support, using its commutes_X property.
Applying the symmetry twice returns the original operator:
By simplification using the definitions. The support of the double-transformed operator is \((S^T)^T = S\) by the transpose involution property.
The symmetry preserves the weight of logical operators:
By simplification using the definitions. The weight of \(S^T = (q^T, p^T)\) is \(|q^T| + |p^T|\). Since transpose is a bijection (using the injectivity of the negation map), we have \(|q^T| = |q|\) and \(|p^T| = |p|\). Therefore the weight is \(|q| + |p| = |p| + |q|\) by ring arithmetic.
The transpose map on BB logical supports is a bijection.
Injectivity: Let \(S_1\) and \(S_2\) be supports with \(S_1^T = S_2^T\). Applying transpose to both sides and using the involution property: \((S_1^T)^T = (S_2^T)^T\), hence \(S_1 = S_2\).
Surjectivity: Given any support \(S\), we have \(S = (S^T)^T\), so \(S^T\) is a preimage of \(S\) under transpose.
A gauging target type specifies whether a gauging measurement targets an X-type or Z-type logical operator. It is an inductive type with two constructors:
\(\text{X}\): an X-type target
\(\text{Z}\): a Z-type target
A gauging target specifies what logical operator to measure. It consists of:
A support: a BB logical support
A target type: either X or Z
The transposed gauging target swaps X and Z types while transposing the support:
\(T^T.\text{support} = T.\text{support}^T\)
\(T^T.\text{targetType} = \begin{cases} \text{Z} & \text{if } T.\text{targetType} = \text{X} \\ \text{X} & \text{if } T.\text{targetType} = \text{Z} \end{cases}\)
Double transpose of a gauging target returns the original:
We case split on the target \(T = (s, t)\). For the support, \((s^T)^T = s\) by the support transpose involution. For the target type, we case split: if \(t = \text{X}\), then \(t^T = \text{Z}\) and \((t^T)^T = \text{X} = t\); similarly for \(t = \text{Z}\).
A gauging graph construction for measuring \(\bar{X}_\alpha = X(\alpha f, 0)\) can be adapted to measure \(\bar{Z}'_\alpha = Z(0, \alpha f^T)\) by swapping left and right qubits.
More precisely: if \(T\) is a gauging target with X-type and left-only support \(\text{leftOnly}(f \cdot \alpha )\), then \(T^T\) satisfies:
\(T^T.\text{support} = \text{rightOnly}((f \cdot \alpha )^T)\)
\(T^T.\text{targetType} = \text{Z}\)
We verify both conditions:
By the transpose of left-only support theorem, \((\text{leftOnly}(f \cdot \alpha ))^T = \text{rightOnly}((f \cdot \alpha )^T)\).
By definition of gauging target transpose, an X-type target becomes a Z-type target.
The transposed target has swapped type:
\(T^T.\text{targetType} = \text{X} \Leftrightarrow T.\text{targetType} = \text{Z}\)
\(T^T.\text{targetType} = \text{Z} \Leftrightarrow T.\text{targetType} = \text{X}\)
By simplification and case analysis on the target type. If \(T.\text{targetType} = \text{X}\), then \(T^T.\text{targetType} = \text{Z}\), and vice versa.
The weight of a support is preserved under transpose:
By definition, \(\text{weight}(S^T) = |q^T| + |p^T|\) where \(S = (p, q)\). Since the negation map is injective, the image of a finite set under negation has the same cardinality. Thus \(|q^T| = |q|\) and \(|p^T| = |p|\), so \(\text{weight}(S^T) = |q| + |p| = |p| + |q| = \text{weight}(S)\) by ring arithmetic.
The zero support has zero weight:
By simplification: the zero support has empty left and right supports, each with cardinality 0, so the total weight is \(0 + 0 = 0\).
For any BB polynomial \(p\):
By simplification: the left-only support \((p, 0)\) has weight \(|p| + |0| = |p| + 0 = |p|\).
For any BB polynomial \(q\):
By simplification: the right-only support \((0, q)\) has weight \(|0| + |q| = 0 + |q| = |q|\).